dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17 #ifdef __cplusplus
  18 /* SwigValueWrapper is described in swig.swg */
  19 template<typename T> class SwigValueWrapper {
  20   struct SwigMovePointer {
  21     T *ptr;
  22     SwigMovePointer(T *p) : ptr(p) { }
  23     ~SwigMovePointer() { delete ptr; }
  24     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  25   } pointer;
  26   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  28 public:
  29   SwigValueWrapper() : pointer(0) { }
  30   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  31   operator T&() const { return *pointer.ptr; }
  32   T *operator&() { return pointer.ptr; }
  33 };
  34
  35 template <typename T> T SwigValueInit() {
  36   return T();
  37 }
  38 #endif
  39
  40 /* -----------------------------------------------------------------------------
  41  *  This section contains generic SWIG labels for method/variable
  42  *  declarations/attributes, and other compiler dependent labels.
  43  * ----------------------------------------------------------------------------- */
  44
  45 /* template workaround for compilers that cannot correctly implement the C++ standard */
  46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  48 #  define SWIGTEMPLATEDISAMBIGUATOR template
  49 # elif defined(__HP_aCC)
  50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  52 #  define SWIGTEMPLATEDISAMBIGUATOR template
  53 # else
  54 #  define SWIGTEMPLATEDISAMBIGUATOR
  55 # endif
  56 #endif
  57
  58 /* inline attribute */
  59 #ifndef SWIGINLINE
  60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  61 #   define SWIGINLINE inline
  62 # else
  63 #   define SWIGINLINE
  64 # endif
  65 #endif
  66
  67 /* attribute recognised by some compilers to avoid 'unused' warnings */
  68 #ifndef SWIGUNUSED
  69 # if defined(__GNUC__)
  70 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  71 #     define SWIGUNUSED __attribute__ ((__unused__))
  72 #   else
  73 #     define SWIGUNUSED
  74 #   endif
  75 # elif defined(__ICC)
  76 #   define SWIGUNUSED __attribute__ ((__unused__))
  77 # else
  78 #   define SWIGUNUSED
  79 # endif
  80 #endif
  81
  82 #ifndef SWIG_MSC_UNSUPPRESS_4505
  83 # if defined(_MSC_VER)
  84 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  85 # endif
  86 #endif
  87
  88 #ifndef SWIGUNUSEDPARM
  89 # ifdef __cplusplus
  90 #   define SWIGUNUSEDPARM(p)
  91 # else
  92 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  93 # endif
  94 #endif
  95
  96 /* internal SWIG method */
  97 #ifndef SWIGINTERN
  98 # define SWIGINTERN static SWIGUNUSED
  99 #endif
 100
 101 /* internal inline SWIG method */
 102 #ifndef SWIGINTERNINLINE
 103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 104 #endif
 105
 106 /* exporting methods */
 107 #if defined(__GNUC__)
 108 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 109 #    ifndef GCC_HASCLASSVISIBILITY
 110 #      define GCC_HASCLASSVISIBILITY
 111 #    endif
 112 #  endif
 113 #endif
 114
 115 #ifndef SWIGEXPORT
 116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 117 #   if defined(STATIC_LINKED)
 118 #     define SWIGEXPORT
 119 #   else
 120 #     define SWIGEXPORT __declspec(dllexport)
 121 #   endif
 122 # else
 123 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 124 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 125 #   else
 126 #     define SWIGEXPORT
 127 #   endif
 128 # endif
 129 #endif
 130
 131 /* calling conventions for Windows */
 132 #ifndef SWIGSTDCALL
 133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 134 #   define SWIGSTDCALL __stdcall
 135 # else
 136 #   define SWIGSTDCALL
 137 # endif
 138 #endif
 139
 140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 142 # define _CRT_SECURE_NO_DEPRECATE
 143 #endif
 144
 145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 147 # define _SCL_SECURE_NO_DEPRECATE
 148 #endif
 149
 150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 153 #endif
 154
 155 /* Intel's compiler complains if a variable which was never initialised is
 156  * cast to void, which is a common idiom which we use to indicate that we
 157  * are aware a variable isn't used.  So we just silence that warning.
 158  * See: https://github.com/swig/swig/issues/192 for more discussion.
 159  */
 160 #ifdef __INTEL_COMPILER
 161 # pragma warning disable 592
 162 #endif
 163
 164
 165 #include <stdlib.h>
 166 #include <string.h>
 167 #include <stdio.h>
 168
 169 /* Support for throwing C# exceptions from C/C++. There are two types:
 170  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 171 typedef enum {
 172   SWIG_CSharpApplicationException,
 173   SWIG_CSharpArithmeticException,
 174   SWIG_CSharpDivideByZeroException,
 175   SWIG_CSharpIndexOutOfRangeException,
 176   SWIG_CSharpInvalidCastException,
 177   SWIG_CSharpInvalidOperationException,
 178   SWIG_CSharpIOException,
 179   SWIG_CSharpNullReferenceException,
 180   SWIG_CSharpOutOfMemoryException,
 181   SWIG_CSharpOverflowException,
 182   SWIG_CSharpSystemException
 183 } SWIG_CSharpExceptionCodes;
 184
 185 typedef enum {
 186   SWIG_CSharpArgumentException,
 187   SWIG_CSharpArgumentNullException,
 188   SWIG_CSharpArgumentOutOfRangeException
 189 } SWIG_CSharpExceptionArgumentCodes;
 190
 191 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 192 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 193
 194 typedef struct {
 195   SWIG_CSharpExceptionCodes code;
 196   SWIG_CSharpExceptionCallback_t callback;
 197 } SWIG_CSharpException_t;
 198
 199 typedef struct {
 200   SWIG_CSharpExceptionArgumentCodes code;
 201   SWIG_CSharpExceptionArgumentCallback_t callback;
 202 } SWIG_CSharpExceptionArgument_t;
 203
 204 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 205   { SWIG_CSharpApplicationException, NULL },
 206   { SWIG_CSharpArithmeticException, NULL },
 207   { SWIG_CSharpDivideByZeroException, NULL },
 208   { SWIG_CSharpIndexOutOfRangeException, NULL },
 209   { SWIG_CSharpInvalidCastException, NULL },
 210   { SWIG_CSharpInvalidOperationException, NULL },
 211   { SWIG_CSharpIOException, NULL },
 212   { SWIG_CSharpNullReferenceException, NULL },
 213   { SWIG_CSharpOutOfMemoryException, NULL },
 214   { SWIG_CSharpOverflowException, NULL },
 215   { SWIG_CSharpSystemException, NULL }
 216 };
 217
 218 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 219   { SWIG_CSharpArgumentException, NULL },
 220   { SWIG_CSharpArgumentNullException, NULL },
 221   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 222 };
 223
 224 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 225   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 226   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 227     callback = SWIG_csharp_exceptions[code].callback;
 228   }
 229   callback(msg);
 230 }
 231
 232 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 233   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 234   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 235     callback = SWIG_csharp_exceptions_argument[code].callback;
 236   }
 237   callback(msg, param_name);
 238 }
 239
 240
 241 #ifdef __cplusplus
 242 extern "C"
 243 #endif
 244 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 245                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 246                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 247                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 248                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 249                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 250                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 251                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 252                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 253                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 254                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 255                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 256   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 257   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 258   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 267 }
 268
 269 #ifdef __cplusplus
 270 extern "C"
 271 #endif
 272 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 273                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 274                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 276   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 277   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 279 }
 280
 281
 282 /* Callback for returning strings to C# without leaking memory */
 283 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 284 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 285
 286 // keep argWidgetCs and argWidgetV so they're always available to DALi
 287 int argWidgetC = 1;
 288 char **argWidgetV = NULL;
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/devel-api/actors/actor-devel.h>
 427 #include <dali/devel-api/common/stage-devel.h>
 428 #include <dali/devel-api/events/key-event-devel.h>
 429
 430 #include <dali/public-api/math/matrix.h>
 431 #include <dali/public-api/math/matrix3.h>
 432 #include <dali/public-api/math/viewport.h>
 433 #include <dali/public-api/object/property-key.h>
 434 #include <dali/devel-api/object/csharp-type-info.h>
 435 #include <dali/devel-api/object/csharp-type-registry.h>
 436
 437 #include <dali/public-api/adaptor-framework/timer.h>
 438 #include <dali/public-api/adaptor-framework/style-change.h>
 439 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 440
 441 #include <dali-toolkit/devel-api/accessibility-manager/accessibility-manager.h>
 442
 443 #include <dali-toolkit/devel-api/builder/builder.h>
 444
 445 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 446 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 447
 448 #include <dali-toolkit/devel-api/controls/control-devel.h>
 449 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 450 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 455 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 456 #include <dali-toolkit/devel-api/controls/alignment/alignment.h>
 457 #include <dali-toolkit/devel-api/controls/scroll-bar/scroll-bar.h>
 458 #include <dali-toolkit/devel-api/controls/table-view/table-view.h>
 459
 460 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 461 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 462 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 463
 464 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 465 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 466 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 467
 468 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 469 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 470 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 471
 472 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 473
 474 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 475 #include <dali/devel-api/adaptor-framework/image-loading.h>
 476
 477 #include <dali/public-api/events/mouse-button.h>
 478
 479 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 480 #include "web-view-signal-converter.h"
 481
 482 #include <dali/integration-api/debug.h>
 483
 484 #include <dali-toolkit/devel-api/controls/video-view/video-view-devel.h>
 485
 486 #include <dali/devel-api/adaptor-framework/native-image-source-devel.h>
 487
 488 #include <dali-toolkit/devel-api/text/rendering-backend.h>
 489
 490
 491 #include <dali/devel-api/update/frame-callback-interface.h>
 492 #include <dali/devel-api/update/update-proxy.h>
 493
 494
 495 // add here SWIG version check
 496
 497 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 498 // disable Swig-dependent warnings
 499
 500 // 'identifier1' has C-linkage specified,
 501 // but returns UDT 'identifier2' which is incompatible with C
 502 #pragma warning(disable: 4190)
 503
 504 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 505 #pragma warning(disable: 4800)
 506
 507 // debug info too long etc etc
 508 #pragma warning(disable: 4786)
 509 #endif
 510
 511
 512 #include <stdexcept>
 513
 514
 515 #include <string>
 516
 517
 518 #include <vector>
 519 #include <algorithm>
 520 #include <stdexcept>
 521
 522
 523 #include <map>
 524 #include <algorithm>
 525 #include <stdexcept>
 526
 527
 528 #include <utility>
 529
 530
 531 typedef float floatp;
 532
 533 SWIGINTERN floatp *new_floatp(){
 534   return new float();
 535 }
 536 SWIGINTERN void delete_floatp(floatp *self){
 537   if (self) delete self;
 538 }
 539 SWIGINTERN void floatp_assign(floatp *self,float value){
 540   *self = value;
 541 }
 542 SWIGINTERN float floatp_value(floatp *self){
 543   return *self;
 544 }
 545 SWIGINTERN float *floatp_cast(floatp *self){
 546   return self;
 547 }
 548 SWIGINTERN floatp *floatp_frompointer(float *t){
 549   return (floatp *) t;
 550 }
 551
 552 typedef int intp;
 553
 554 SWIGINTERN intp *new_intp(){
 555   return new int();
 556 }
 557 SWIGINTERN void delete_intp(intp *self){
 558   if (self) delete self;
 559 }
 560 SWIGINTERN void intp_assign(intp *self,int value){
 561   *self = value;
 562 }
 563 SWIGINTERN int intp_value(intp *self){
 564   return *self;
 565 }
 566 SWIGINTERN int *intp_cast(intp *self){
 567   return self;
 568 }
 569 SWIGINTERN intp *intp_frompointer(int *t){
 570   return (intp *) t;
 571 }
 572
 573 typedef double doublep;
 574
 575 SWIGINTERN doublep *new_doublep(){
 576   return new double();
 577 }
 578 SWIGINTERN void delete_doublep(doublep *self){
 579   if (self) delete self;
 580 }
 581 SWIGINTERN void doublep_assign(doublep *self,double value){
 582   *self = value;
 583 }
 584 SWIGINTERN double doublep_value(doublep *self){
 585   return *self;
 586 }
 587 SWIGINTERN double *doublep_cast(doublep *self){
 588   return self;
 589 }
 590 SWIGINTERN doublep *doublep_frompointer(double *t){
 591   return (doublep *) t;
 592 }
 593
 594 typedef unsigned int uintp;
 595
 596 SWIGINTERN uintp *new_uintp(){
 597   return new unsigned int();
 598 }
 599 SWIGINTERN void delete_uintp(uintp *self){
 600   if (self) delete self;
 601 }
 602 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 603   *self = value;
 604 }
 605 SWIGINTERN unsigned int uintp_value(uintp *self){
 606   return *self;
 607 }
 608 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 609   return self;
 610 }
 611 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 612   return (uintp *) t;
 613 }
 614
 615 typedef unsigned short ushortp;
 616
 617 SWIGINTERN ushortp *new_ushortp(){
 618   return new unsigned short();
 619 }
 620 SWIGINTERN void delete_ushortp(ushortp *self){
 621   if (self) delete self;
 622 }
 623 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 624   *self = value;
 625 }
 626 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 627   return *self;
 628 }
 629 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 630   return self;
 631 }
 632 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 633   return (ushortp *) t;
 634 }
 635
 636 unsigned int int_to_uint(int x) {
 637    return (unsigned int) x;
 638 }
 639
 640
 641 using namespace Dali;
 642 using namespace Dali::Toolkit;
 643
 644 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 645 {
 646   bool result = false;
 647   try
 648   {
 649     // C++ code. DALi uses Handle <-> Body design pattern.
 650     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 651     // Handles in DALi can be converted into a boolean type
 652     // to check if the handle has a valid body attached to it.
 653     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 654     if( *self )
 655     {
 656       result = true;
 657     }
 658     else
 659     {
 660       result = false;
 661     }
 662   }
 663   catch (std::out_of_range& e)
 664   {
 665     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 666     return 0;
 667   }
 668   catch (std::exception& e)
 669   {
 670     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 671     return 0;
 672   }
 673   catch (DaliException e)
 674   {
 675     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 676     return 0;
 677   }
 678   catch (...)
 679   {
 680     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 681     return 0;
 682   }
 683   return result;
 684 }
 685
 686 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 687 {
 688   bool result = false;
 689   try
 690   {
 691     // C++ code. Check if two handles reference the same implemtion
 692     if( *self == rhs)
 693     {
 694       result = true;
 695     }
 696     else
 697     {
 698       result = false;
 699     }
 700   }
 701   catch (std::out_of_range& e)
 702   {
 703     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 704     return 0;
 705   }
 706   catch (std::exception& e)
 707   {
 708     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 709     return 0;
 710   }
 711   catch (DaliException e)
 712   {
 713     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 714     return 0;
 715   }
 716   catch (...)
 717   {
 718     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 719     return 0;
 720   }
 721   return result;
 722 }
 723
 724
 725 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 726      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 727    }
 728 SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){
 729      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 730    }
 731 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 732         std::vector< Dali::TouchPoint >* pv = 0;
 733         if (capacity >= 0) {
 734           pv = new std::vector< Dali::TouchPoint >();
 735           pv->reserve(capacity);
 736        } else {
 737           throw std::out_of_range("capacity");
 738        }
 739        return pv;
 740       }
 741 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 742         if (index>=0 && index<(int)self->size())
 743           return (*self)[index];
 744         else
 745           throw std::out_of_range("index");
 746       }
 747 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 748         if (index>=0 && index<(int)self->size())
 749           return (*self)[index];
 750         else
 751           throw std::out_of_range("index");
 752       }
 753 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 754         if (index>=0 && index<(int)self->size())
 755           (*self)[index] = val;
 756         else
 757           throw std::out_of_range("index");
 758       }
 759 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 760         self->insert(self->end(), values.begin(), values.end());
 761       }
 762 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 763         if (index < 0)
 764           throw std::out_of_range("index");
 765         if (count < 0)
 766           throw std::out_of_range("count");
 767         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 768           throw std::invalid_argument("invalid range");
 769         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 770       }
 771 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 772         if (index>=0 && index<(int)self->size()+1)
 773           self->insert(self->begin()+index, x);
 774         else
 775           throw std::out_of_range("index");
 776       }
 777 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 778         if (index>=0 && index<(int)self->size()+1)
 779           self->insert(self->begin()+index, values.begin(), values.end());
 780         else
 781           throw std::out_of_range("index");
 782       }
 783 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 784         if (index>=0 && index<(int)self->size())
 785           self->erase(self->begin() + index);
 786         else
 787           throw std::out_of_range("index");
 788       }
 789 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 790         if (index < 0)
 791           throw std::out_of_range("index");
 792         if (count < 0)
 793           throw std::out_of_range("count");
 794         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 795           throw std::invalid_argument("invalid range");
 796         self->erase(self->begin()+index, self->begin()+index+count);
 797       }
 798 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 799         if (count < 0)
 800           throw std::out_of_range("count");
 801         return new std::vector< Dali::TouchPoint >(count, value);
 802       }
 803 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 804         std::reverse(self->begin(), self->end());
 805       }
 806 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 807         if (index < 0)
 808           throw std::out_of_range("index");
 809         if (count < 0)
 810           throw std::out_of_range("count");
 811         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 812           throw std::invalid_argument("invalid range");
 813         std::reverse(self->begin()+index, self->begin()+index+count);
 814       }
 815 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 816         if (index < 0)
 817           throw std::out_of_range("index");
 818         if (index+values.size() > self->size())
 819           throw std::out_of_range("index");
 820         std::copy(values.begin(), values.end(), self->begin()+index);
 821       }
 822 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 823          return self->Empty();
 824       }
 825 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 826         return self->GetConnectionCount();
 827       }
 828 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 829           self->Connect( func );
 830       }
 831 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 832           self->Disconnect( func );
 833       }
 834 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 835           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 836 /*@SWIG@*/ self->Emit( arg );
 837       }
 838 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 839          return self->Empty();
 840       }
 841 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 842         return self->GetConnectionCount();
 843       }
 844 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 845           self->Connect( func );
 846       }
 847 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 848           self->Disconnect( func );
 849       }
 850 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 851           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 852 /*@SWIG@*/ self->Emit( arg );
 853       }
 854 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 855          return self->Empty();
 856       }
 857 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
 858         return self->GetConnectionCount();
 859       }
 860 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 861           self->Connect( func );
 862       }
 863 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 864           self->Disconnect( func );
 865       }
 866 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
 867           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 868 /*@SWIG@*/ self->Emit( arg );
 869       }
 870 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 871          return self->Empty();
 872       }
 873 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 874         return self->GetConnectionCount();
 875       }
 876 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 877           self->Connect( func );
 878       }
 879 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 880           self->Disconnect( func );
 881       }
 882 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 883           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 884 /*@SWIG@*/ self->Emit( arg );
 885       }
 886 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 887          return self->Empty();
 888       }
 889 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 890         return self->GetConnectionCount();
 891       }
 892 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 893         self->Connect( func );
 894       }
 895 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 896         self->Disconnect( func );
 897       }
 898 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 899         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 900 /*@SWIG@*/ self->Emit( arg1, arg2 );
 901       }
 902 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 903          return self->Empty();
 904       }
 905 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 906         return self->GetConnectionCount();
 907       }
 908 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 909         self->Connect( func );
 910       }
 911 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 912         self->Disconnect( func );
 913       }
 914 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,Dali::Actor arg1,Dali::TouchData const &arg2){
 915         return self->Emit( arg1, arg2 );
 916       }
 917 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 918          return self->Empty();
 919       }
 920 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 921         return self->GetConnectionCount();
 922       }
 923 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 924         self->Connect( func );
 925       }
 926 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 927         self->Disconnect( func );
 928       }
 929 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,Dali::Actor arg1,Dali::HoverEvent const &arg2){
 930         return self->Emit( arg1, arg2 );
 931       }
 932 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 933          return self->Empty();
 934       }
 935 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 936         return self->GetConnectionCount();
 937       }
 938 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 939         self->Connect( func );
 940       }
 941 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 942         self->Disconnect( func );
 943       }
 944 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,Dali::Actor arg1,Dali::WheelEvent const &arg2){
 945         return self->Emit( arg1, arg2 );
 946       }
 947 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 948          return self->Empty();
 949       }
 950 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 951         return self->GetConnectionCount();
 952       }
 953 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 954           self->Connect( func );
 955       }
 956 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 957           self->Disconnect( func );
 958       }
 959 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 960           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 961 /*@SWIG@*/ self->Emit( arg );
 962       }
 963 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 964          return self->Empty();
 965       }
 966 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 967         return self->GetConnectionCount();
 968       }
 969 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 970           self->Connect( func );
 971       }
 972 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 973           self->Disconnect( func );
 974       }
 975 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){
 976           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 977 /*@SWIG@*/ self->Emit( arg );
 978       }
 979 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 980          return self->Empty();
 981       }
 982 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchData const &) > const *self){
 983         return self->GetConnectionCount();
 984       }
 985 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 986           self->Connect( func );
 987       }
 988 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 989           self->Disconnect( func );
 990       }
 991 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchData const &) > *self,Dali::TouchData const &arg){
 992           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 993 /*@SWIG@*/ self->Emit( arg );
 994       }
 995 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 996          return self->Empty();
 997       }
 998 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 999         return self->GetConnectionCount();
1000       }
1001 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
1002           self->Connect( func );
1003       }
1004 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
1005           self->Disconnect( func );
1006       }
1007 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){
1008           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1009 /*@SWIG@*/ self->Emit( arg );
1010       }
1011 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1012          return self->Empty();
1013       }
1014 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1015         return self->GetConnectionCount();
1016       }
1017 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1018         self->Connect( func );
1019       }
1020 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1021         self->Disconnect( func );
1022       }
1023 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){
1024         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1025 /*@SWIG@*/ self->Emit( arg1, arg2 );
1026       }
1027 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1028          return self->Empty();
1029       }
1030 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1031         return self->GetConnectionCount();
1032       }
1033 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1034         self->Connect( func );
1035       }
1036 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1037         self->Disconnect( func );
1038       }
1039 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){
1040         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1041 /*@SWIG@*/ self->Emit( arg1, arg2 );
1042       }
1043 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1044          return self->Empty();
1045       }
1046 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1047         return self->GetConnectionCount();
1048       }
1049 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1050         self->Connect( func );
1051       }
1052 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1053         self->Disconnect( func );
1054       }
1055 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){
1056         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1057 /*@SWIG@*/ self->Emit( arg1, arg2 );
1058       }
1059 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1060          return self->Empty();
1061       }
1062 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1063         return self->GetConnectionCount();
1064       }
1065 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1066           return self->Connect( func );
1067       }
1068 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1069           self->Disconnect( func );
1070       }
1071 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,Dali::Actor arg1, Dali::LayoutDirection::Type arg3){
1072           self->Emit( arg1, arg3 );
1073       }
1074 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1075          return self->Empty();
1076       }
1077 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1078         return self->GetConnectionCount();
1079       }
1080 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1081           return self->Connect( func );
1082       }
1083 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1084           self->Disconnect( func );
1085       }
1086 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,Dali::Actor arg1,bool arg2,Dali::DevelActor::VisibilityChange::Type arg3){
1087           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1088 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1089       }
1090
1091 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1092          return self->Empty();
1093       }
1094 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1095         return self->GetConnectionCount();
1096       }
1097 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1098           self->Connect( func );
1099       }
1100 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1101           self->Disconnect( func );
1102       }
1103 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1104           return self->Emit();
1105       }
1106
1107 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1108         std::vector< unsigned int >* pv = 0;
1109         if (capacity >= 0) {
1110           pv = new std::vector< unsigned int >();
1111           pv->reserve(capacity);
1112        } else {
1113           throw std::out_of_range("capacity");
1114        }
1115        return pv;
1116       }
1117 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1118         if (index>=0 && index<(int)self->size())
1119           return (*self)[index];
1120         else
1121           throw std::out_of_range("index");
1122       }
1123 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1124         if (index>=0 && index<(int)self->size())
1125           return (*self)[index];
1126         else
1127           throw std::out_of_range("index");
1128       }
1129 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1130         if (index>=0 && index<(int)self->size())
1131           (*self)[index] = val;
1132         else
1133           throw std::out_of_range("index");
1134       }
1135 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1136         self->insert(self->end(), values.begin(), values.end());
1137       }
1138 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1139         if (index < 0)
1140           throw std::out_of_range("index");
1141         if (count < 0)
1142           throw std::out_of_range("count");
1143         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1144           throw std::invalid_argument("invalid range");
1145         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1146       }
1147 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1148         if (index>=0 && index<(int)self->size()+1)
1149           self->insert(self->begin()+index, x);
1150         else
1151           throw std::out_of_range("index");
1152       }
1153 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1154         if (index>=0 && index<(int)self->size()+1)
1155           self->insert(self->begin()+index, values.begin(), values.end());
1156         else
1157           throw std::out_of_range("index");
1158       }
1159 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1160         if (index>=0 && index<(int)self->size())
1161           self->erase(self->begin() + index);
1162         else
1163           throw std::out_of_range("index");
1164       }
1165 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1166         if (index < 0)
1167           throw std::out_of_range("index");
1168         if (count < 0)
1169           throw std::out_of_range("count");
1170         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1171           throw std::invalid_argument("invalid range");
1172         self->erase(self->begin()+index, self->begin()+index+count);
1173       }
1174 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1175         if (count < 0)
1176           throw std::out_of_range("count");
1177         return new std::vector< unsigned int >(count, value);
1178       }
1179 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1180         std::reverse(self->begin(), self->end());
1181       }
1182 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1183         if (index < 0)
1184           throw std::out_of_range("index");
1185         if (count < 0)
1186           throw std::out_of_range("count");
1187         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1188           throw std::invalid_argument("invalid range");
1189         std::reverse(self->begin()+index, self->begin()+index+count);
1190       }
1191 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1192         if (index < 0)
1193           throw std::out_of_range("index");
1194         if (index+values.size() > self->size())
1195           throw std::out_of_range("index");
1196         std::copy(values.begin(), values.end(), self->begin()+index);
1197       }
1198 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1199         return std::find(self->begin(), self->end(), value) != self->end();
1200       }
1201 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1202         int index = -1;
1203         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1204         if (it != self->end())
1205           index = (int)(it - self->begin());
1206         return index;
1207       }
1208 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1209         int index = -1;
1210         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1211         if (rit != self->rend())
1212           index = (int)(self->rend() - 1 - rit);
1213         return index;
1214       }
1215 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1216         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1217         if (it != self->end()) {
1218           self->erase(it);
1219           return true;
1220         }
1221         return false;
1222       }
1223 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(int capacity){
1224         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1225         if (capacity >= 0) {
1226           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1227           pv->reserve(capacity);
1228        } else {
1229           throw std::out_of_range("capacity");
1230        }
1231        return pv;
1232       }
1233 SWIGINTERN std::pair< unsigned int,Dali::Actor > std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1234         if (index>=0 && index<(int)self->size())
1235           return (*self)[index];
1236         else
1237           throw std::out_of_range("index");
1238       }
1239 SWIGINTERN std::pair< unsigned int,Dali::Actor > const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1240         if (index>=0 && index<(int)self->size())
1241           return (*self)[index];
1242         else
1243           throw std::out_of_range("index");
1244       }
1245 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
1246         if (index>=0 && index<(int)self->size())
1247           (*self)[index] = val;
1248         else
1249           throw std::out_of_range("index");
1250       }
1251 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1252         self->insert(self->end(), values.begin(), values.end());
1253       }
1254 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1255         if (index < 0)
1256           throw std::out_of_range("index");
1257         if (count < 0)
1258           throw std::out_of_range("count");
1259         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1260           throw std::invalid_argument("invalid range");
1261         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1262       }
1263 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &x){
1264         if (index>=0 && index<(int)self->size()+1)
1265           self->insert(self->begin()+index, x);
1266         else
1267           throw std::out_of_range("index");
1268       }
1269 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1270         if (index>=0 && index<(int)self->size()+1)
1271           self->insert(self->begin()+index, values.begin(), values.end());
1272         else
1273           throw std::out_of_range("index");
1274       }
1275 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1276         if (index>=0 && index<(int)self->size())
1277           self->erase(self->begin() + index);
1278         else
1279           throw std::out_of_range("index");
1280       }
1281 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1282         if (index < 0)
1283           throw std::out_of_range("index");
1284         if (count < 0)
1285           throw std::out_of_range("count");
1286         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1287           throw std::invalid_argument("invalid range");
1288         self->erase(self->begin()+index, self->begin()+index+count);
1289       }
1290 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat(std::pair< unsigned int,Dali::Actor > const &value,int count){
1291         if (count < 0)
1292           throw std::out_of_range("count");
1293         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1294       }
1295 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< unsigned int,Dali::Actor > > *self){
1296         std::reverse(self->begin(), self->end());
1297       }
1298 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1299         if (index < 0)
1300           throw std::out_of_range("index");
1301         if (count < 0)
1302           throw std::out_of_range("count");
1303         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1304           throw std::invalid_argument("invalid range");
1305         std::reverse(self->begin()+index, self->begin()+index+count);
1306       }
1307 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1308         if (index < 0)
1309           throw std::out_of_range("index");
1310         if (index+values.size() > self->size())
1311           throw std::out_of_range("index");
1312         std::copy(values.begin(), values.end(), self->begin()+index);
1313       }
1314 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1315         std::vector< Dali::Actor >* pv = 0;
1316         if (capacity >= 0) {
1317           pv = new std::vector< Dali::Actor >();
1318           pv->reserve(capacity);
1319        } else {
1320           throw std::out_of_range("capacity");
1321        }
1322        return pv;
1323       }
1324 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1325         if (index>=0 && index<(int)self->size())
1326           return (*self)[index];
1327         else
1328           throw std::out_of_range("index");
1329       }
1330 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1331         if (index>=0 && index<(int)self->size())
1332           return (*self)[index];
1333         else
1334           throw std::out_of_range("index");
1335       }
1336 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1337         if (index>=0 && index<(int)self->size())
1338           (*self)[index] = val;
1339         else
1340           throw std::out_of_range("index");
1341       }
1342 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1343         self->insert(self->end(), values.begin(), values.end());
1344       }
1345 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1346         if (index < 0)
1347           throw std::out_of_range("index");
1348         if (count < 0)
1349           throw std::out_of_range("count");
1350         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1351           throw std::invalid_argument("invalid range");
1352         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1353       }
1354 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1355         if (index>=0 && index<(int)self->size()+1)
1356           self->insert(self->begin()+index, x);
1357         else
1358           throw std::out_of_range("index");
1359       }
1360 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1361         if (index>=0 && index<(int)self->size()+1)
1362           self->insert(self->begin()+index, values.begin(), values.end());
1363         else
1364           throw std::out_of_range("index");
1365       }
1366 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1367         if (index>=0 && index<(int)self->size())
1368           self->erase(self->begin() + index);
1369         else
1370           throw std::out_of_range("index");
1371       }
1372 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1373         if (index < 0)
1374           throw std::out_of_range("index");
1375         if (count < 0)
1376           throw std::out_of_range("count");
1377         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1378           throw std::invalid_argument("invalid range");
1379         self->erase(self->begin()+index, self->begin()+index+count);
1380       }
1381 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1382         if (count < 0)
1383           throw std::out_of_range("count");
1384         return new std::vector< Dali::Actor >(count, value);
1385       }
1386 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1387         std::reverse(self->begin(), self->end());
1388       }
1389 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1390         if (index < 0)
1391           throw std::out_of_range("index");
1392         if (count < 0)
1393           throw std::out_of_range("count");
1394         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1395           throw std::invalid_argument("invalid range");
1396         std::reverse(self->begin()+index, self->begin()+index+count);
1397       }
1398 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1399         if (index < 0)
1400           throw std::out_of_range("index");
1401         if (index+values.size() > self->size())
1402           throw std::out_of_range("index");
1403         std::copy(values.begin(), values.end(), self->begin()+index);
1404       }
1405 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1406          return self->Empty();
1407       }
1408 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1409         return self->GetConnectionCount();
1410       }
1411 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1412           self->Connect( func );
1413       }
1414 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1415           self->Disconnect( func );
1416       }
1417 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,Dali::Toolkit::AccessibilityManager &arg){
1418           return self->Emit( arg );
1419       }
1420 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1421          return self->Empty();
1422       }
1423 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1424         return self->GetConnectionCount();
1425       }
1426 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1427         self->Connect( func );
1428       }
1429 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1430         self->Disconnect( func );
1431       }
1432 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,Dali::Actor arg1,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg2){
1433         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1434 /*@SWIG@*/ self->Emit( arg1, arg2 );
1435       }
1436 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1437          return self->Empty();
1438       }
1439 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1440         return self->GetConnectionCount();
1441       }
1442 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1443         self->Connect( func );
1444       }
1445 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1446         self->Disconnect( func );
1447       }
1448 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,Dali::Actor arg1,Dali::Actor arg2){
1449         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1450 /*@SWIG@*/ self->Emit( arg1, arg2 );
1451       }
1452 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1453          return self->Empty();
1454       }
1455 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1456         return self->GetConnectionCount();
1457       }
1458 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1459         self->Connect( func );
1460       }
1461 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1462         self->Disconnect( func );
1463       }
1464 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool) > *self,Dali::Actor arg1,bool arg2){
1465         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1466 /*@SWIG@*/ self->Emit( arg1, arg2 );
1467       }
1468 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1469          return self->Empty();
1470       }
1471 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1472         return self->GetConnectionCount();
1473       }
1474 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1475         self->Connect( func );
1476       }
1477 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1478         self->Disconnect( func );
1479       }
1480 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,Dali::Toolkit::StyleManager arg1,Dali::StyleChange::Type arg2){
1481         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1482 /*@SWIG@*/ self->Emit( arg1, arg2 );
1483       }
1484 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1485          return self->Empty();
1486       }
1487 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1488         return self->GetConnectionCount();
1489       }
1490 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1491           self->Connect( func );
1492       }
1493 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1494           self->Disconnect( func );
1495       }
1496 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1497           return self->Emit( arg );
1498       }
1499 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1500          return self->Empty();
1501       }
1502 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1503         return self->GetConnectionCount();
1504       }
1505 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1506           self->Connect( func );
1507       }
1508 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1509           self->Disconnect( func );
1510       }
1511 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1512           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1513 /*@SWIG@*/ self->Emit( arg );
1514       }
1515 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1516          return self->Empty();
1517       }
1518 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1519         return self->GetConnectionCount();
1520       }
1521 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1522           return self->Connect( func );
1523       }
1524 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1525           self->Disconnect( func );
1526       }
1527 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,Dali::Toolkit::PageTurnView arg1,unsigned int arg2,bool arg3){
1528           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1529 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1530       }
1531 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1532          return self->Empty();
1533       }
1534 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1535         return self->GetConnectionCount();
1536       }
1537 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1538           self->Connect( func );
1539       }
1540 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1541           self->Disconnect( func );
1542       }
1543 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1544           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1545 /*@SWIG@*/ self->Emit( arg );
1546       }
1547 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1548          return self->Empty();
1549       }
1550 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1551         return self->GetConnectionCount();
1552       }
1553 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1554           return self->Connect( func );
1555       }
1556 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1557           self->Disconnect( func );
1558       }
1559 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,Dali::Toolkit::ProgressBar arg1,float arg2,float arg3){
1560           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1561 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1562       }
1563 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1564          return self->Empty();
1565       }
1566 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1567         return self->GetConnectionCount();
1568       }
1569 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1570           self->Connect( func );
1571       }
1572 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1573           self->Disconnect( func );
1574       }
1575 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,Dali::Toolkit::ScrollView::SnapEvent const &arg){
1576           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1577 /*@SWIG@*/ self->Emit( arg );
1578       }
1579 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1580          return self->Empty();
1581       }
1582 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1583         return self->GetConnectionCount();
1584       }
1585 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1586           self->Connect( func );
1587       }
1588 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1589           self->Disconnect( func );
1590       }
1591 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Vector2 const &) > *self,Dali::Vector2 const &arg){
1592           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1593 /*@SWIG@*/ self->Emit( arg );
1594       }
1595
1596
1597 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1598          return self->Empty();
1599       }
1600 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1601         return self->GetConnectionCount();
1602       }
1603 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1604         self->Connect( func );
1605       }
1606 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1607         self->Disconnect( func );
1608       }
1609 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,Dali::Toolkit::Control arg1,Dali::KeyEvent const &arg2){
1610         return self->Emit( arg1, arg2 );
1611       }
1612 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1613          return self->Empty();
1614       }
1615 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1616         return self->GetConnectionCount();
1617       }
1618 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1619           self->Connect( func );
1620       }
1621 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1622           self->Disconnect( func );
1623       }
1624 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1625           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1626 /*@SWIG@*/ self->Emit( arg );
1627       }
1628 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1629          return self->Empty();
1630       }
1631 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1632         return self->GetConnectionCount();
1633       }
1634 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1635           self->Connect( func );
1636       }
1637 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1638           self->Disconnect( func );
1639       }
1640 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,Dali::Toolkit::VideoView &arg){
1641           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1642 /*@SWIG@*/ self->Emit( arg );
1643       }
1644 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1645          return self->Empty();
1646       }
1647 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1648         return self->GetConnectionCount();
1649       }
1650 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1651         self->Connect( func );
1652       }
1653 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1654         self->Disconnect( func );
1655       }
1656 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,Dali::Toolkit::Slider arg1,float arg2){
1657         return self->Emit( arg1, arg2 );
1658       }
1659 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1660          return self->Empty();
1661       }
1662 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1663         return self->GetConnectionCount();
1664       }
1665 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1666         self->Connect( func );
1667       }
1668 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1669         self->Disconnect( func );
1670       }
1671 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,Dali::Toolkit::Slider arg1,int arg2){
1672         return self->Emit( arg1, arg2 );
1673       }
1674
1675 /* ---------------------------------------------------
1676  * C++ director class methods
1677  * --------------------------------------------------- */
1678
1679 #include "dali_wrap.h"
1680
1681 /*
1682  *  Widget director
1683  */
1684 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1685   swig_init_callbacks();
1686 }
1687
1688 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1689 }
1690
1691 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1692   char * jcontentInfo = 0 ;
1693   void * jwindow  ;
1694
1695   if (!swig_callbackOnCreate) {
1696     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1697     return;
1698   } else {
1699     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1700     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1701     swig_callbackOnCreate(jcontentInfo, jwindow);
1702   }
1703 }
1704
1705 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1706   char * jcontentInfo = 0 ;
1707   int jtype  ;
1708
1709   if (!swig_callbackOnTerminate) {
1710     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1711     return;
1712   } else {
1713     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1714     jtype = (int)type;
1715     swig_callbackOnTerminate(jcontentInfo, jtype);
1716   }
1717 }
1718
1719 void SwigDirector_WidgetImpl::OnPause() {
1720   if (!swig_callbackOnPause) {
1721     Dali::Internal::Adaptor::Widget::OnPause();
1722     return;
1723   } else {
1724     swig_callbackOnPause();
1725   }
1726 }
1727
1728 void SwigDirector_WidgetImpl::OnResume() {
1729   if (!swig_callbackOnResume) {
1730     Dali::Internal::Adaptor::Widget::OnResume();
1731     return;
1732   } else {
1733     swig_callbackOnResume();
1734   }
1735 }
1736
1737 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1738   void * jwindow  ;
1739
1740   if (!swig_callbackOnResize) {
1741     Dali::Internal::Adaptor::Widget::OnResize(window);
1742     return;
1743   } else {
1744     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1745     swig_callbackOnResize(jwindow);
1746   }
1747 }
1748
1749 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1750   char * jcontentInfo = 0 ;
1751   int jforce  ;
1752
1753   if (!swig_callbackOnUpdate) {
1754     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1755     return;
1756   } else {
1757     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1758     jforce = force;
1759     swig_callbackOnUpdate(jcontentInfo, jforce);
1760   }
1761 }
1762
1763 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1764   void * jslotObserver = 0 ;
1765   void * jcallback = 0 ;
1766
1767   if (!swig_callbackSignalConnected) {
1768     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1769     return;
1770   } else {
1771     jslotObserver = (void *) slotObserver;
1772     jcallback = (void *) callback;
1773     swig_callbackSignalConnected(jslotObserver, jcallback);
1774   }
1775 }
1776
1777 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1778   void * jslotObserver = 0 ;
1779   void * jcallback = 0 ;
1780
1781   if (!swig_callbackSignalDisconnected) {
1782     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1783     return;
1784   } else {
1785     jslotObserver = (void *) slotObserver;
1786     jcallback = (void *) callback;
1787     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1788   }
1789 }
1790
1791 void SwigDirector_WidgetImpl::swig_connect_director(SWIG_Callback0_t callbackOnCreate, SWIG_Callback1_t callbackOnTerminate, SWIG_Callback2_t callbackOnPause, SWIG_Callback3_t callbackOnResume, SWIG_Callback4_t callbackOnResize, SWIG_Callback5_t callbackOnUpdate, SWIG_Callback6_t callbackSignalConnected, SWIG_Callback7_t callbackSignalDisconnected) {
1792
1793   swig_callbackOnCreate = callbackOnCreate;
1794   swig_callbackOnTerminate = callbackOnTerminate;
1795   swig_callbackOnPause = callbackOnPause;
1796   swig_callbackOnResume = callbackOnResume;
1797   swig_callbackOnResize = callbackOnResize;
1798   swig_callbackOnUpdate = callbackOnUpdate;
1799   swig_callbackSignalConnected = callbackSignalConnected;
1800   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1801 }
1802
1803 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1804   swig_callbackOnCreate = 0;
1805   swig_callbackOnTerminate = 0;
1806   swig_callbackOnPause = 0;
1807   swig_callbackOnResume = 0;
1808   swig_callbackOnResize = 0;
1809   swig_callbackOnUpdate = 0;
1810   swig_callbackSignalConnected = 0;
1811   swig_callbackSignalDisconnected = 0;
1812 }
1813
1814
1815 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1816   swig_init_callbacks();
1817 }
1818
1819 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1820
1821 }
1822
1823
1824 void SwigDirector_ViewImpl::OnSceneConnection(int depth) {
1825   int jdepth  ;
1826
1827   if (!swig_callbackOnSceneConnection) {
1828     Dali::Toolkit::Internal::Control::OnSceneConnection(depth);
1829     return;
1830   } else {
1831     jdepth = depth;
1832     swig_callbackOnSceneConnection(jdepth);
1833   }
1834 }
1835
1836 void SwigDirector_ViewImpl::OnSceneDisconnection() {
1837   if (!swig_callbackOnSceneDisconnection) {
1838     Dali::Toolkit::Internal::Control::OnSceneDisconnection();
1839     return;
1840   } else {
1841     swig_callbackOnSceneDisconnection();
1842   }
1843 }
1844
1845 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1846   void * jchild = 0 ;
1847
1848   if (!swig_callbackOnChildAdd) {
1849     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1850     return;
1851   } else {
1852     jchild = (Dali::Actor *) &child;
1853     swig_callbackOnChildAdd(jchild);
1854   }
1855 }
1856
1857 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1858   void * jchild = 0 ;
1859
1860   if (!swig_callbackOnChildRemove) {
1861     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1862     return;
1863   } else {
1864     jchild = (Dali::Actor *) &child;
1865     swig_callbackOnChildRemove(jchild);
1866   }
1867 }
1868
1869 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1870   int jindex  ;
1871   void * jpropertyValue  ;
1872
1873   if (!swig_callbackOnPropertySet) {
1874     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1875     return;
1876   } else {
1877     jindex = index;
1878     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1879     swig_callbackOnPropertySet(jindex, jpropertyValue);
1880   }
1881 }
1882
1883 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1884   void * jtargetSize = 0 ;
1885
1886   if (!swig_callbackOnSizeSet) {
1887     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1888     return;
1889   } else {
1890     jtargetSize = (Dali::Vector3 *) &targetSize;
1891     swig_callbackOnSizeSet(jtargetSize);
1892   }
1893 }
1894
1895 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1896   void * janimation = 0 ;
1897   void * jtargetSize = 0 ;
1898
1899   if (!swig_callbackOnSizeAnimation) {
1900     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1901     return;
1902   } else {
1903     janimation = (Dali::Animation *) &animation;
1904     jtargetSize = (Dali::Vector3 *) &targetSize;
1905     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1906   }
1907 }
1908
1909 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1910   bool c_result = SwigValueInit< bool >() ;
1911   unsigned int jresult = 0 ;
1912   void * jarg0 = 0 ;
1913
1914   if (!swig_callbackOnHoverEvent) {
1915     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1916   } else {
1917     jarg0 = (Dali::HoverEvent *) &event;
1918     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1919     c_result = jresult ? true : false;
1920   }
1921   return c_result;
1922 }
1923
1924 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1925   bool c_result = SwigValueInit< bool >() ;
1926   unsigned int jresult = 0 ;
1927   void * jarg0 = 0 ;
1928
1929   if (!swig_callbackOnKeyEvent) {
1930     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1931   } else {
1932     jarg0 = (Dali::KeyEvent *) &event;
1933     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1934     c_result = jresult ? true : false;
1935   }
1936   return c_result;
1937 }
1938
1939 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1940   bool c_result = SwigValueInit< bool >() ;
1941   unsigned int jresult = 0 ;
1942   void * jarg0 = 0 ;
1943
1944   if (!swig_callbackOnWheelEvent) {
1945     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1946   } else {
1947     jarg0 = (Dali::WheelEvent *) &event;
1948     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1949     c_result = jresult ? true : false;
1950   }
1951   return c_result;
1952 }
1953
1954 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1955   void * jsize = 0 ;
1956   void * jcontainer = 0 ;
1957
1958   if (!swig_callbackOnRelayout) {
1959     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1960     return;
1961   } else {
1962     jsize = (Dali::Vector2 *) &size;
1963     jcontainer = (Dali::RelayoutContainer *) &container;
1964     swig_callbackOnRelayout(jsize, jcontainer);
1965   }
1966 }
1967
1968 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1969   int jpolicy  ;
1970   int jdimension  ;
1971
1972   if (!swig_callbackOnSetResizePolicy) {
1973     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1974     return;
1975   } else {
1976     jpolicy = (int)policy;
1977     jdimension = (int)dimension;
1978     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1979   }
1980 }
1981
1982 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1983   Dali::Vector3 c_result ;
1984   void * jresult = 0 ;
1985
1986   if (!swig_callbackGetNaturalSize) {
1987     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1988   } else {
1989     jresult = (void *) swig_callbackGetNaturalSize();
1990     if (!jresult) {
1991       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1992       return c_result;
1993     }
1994     c_result = *(Dali::Vector3 *)jresult;
1995   }
1996   return c_result;
1997 }
1998
1999 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2000   float c_result = SwigValueInit< float >() ;
2001   float jresult = 0 ;
2002   void * jchild = 0 ;
2003   int jdimension  ;
2004
2005   if (!swig_callbackCalculateChildSize) {
2006     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2007   } else {
2008     jchild = (Dali::Actor *) &child;
2009     jdimension = (int)dimension;
2010     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2011     c_result = (float)jresult;
2012   }
2013   return c_result;
2014 }
2015
2016 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2017   float c_result = SwigValueInit< float >() ;
2018   float jresult = 0 ;
2019   float jwidth  ;
2020
2021   if (!swig_callbackGetHeightForWidth) {
2022     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2023   } else {
2024     jwidth = width;
2025     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2026     c_result = (float)jresult;
2027   }
2028   return c_result;
2029 }
2030
2031 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2032   float c_result = SwigValueInit< float >() ;
2033   float jresult = 0 ;
2034   float jheight  ;
2035
2036   if (!swig_callbackGetWidthForHeight) {
2037     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2038   } else {
2039     jheight = height;
2040     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2041     c_result = (float)jresult;
2042   }
2043   return c_result;
2044 }
2045
2046 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2047   bool c_result = SwigValueInit< bool >() ;
2048   unsigned int jresult = 0 ;
2049   int jdimension  ;
2050
2051   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2052     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2053   } else {
2054     jdimension = (int)dimension;
2055     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2056     c_result = jresult ? true : false;
2057   }
2058   return c_result;
2059 }
2060
2061 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2062   int jdimension  ;
2063
2064   if (!swig_callbackOnCalculateRelayoutSize) {
2065     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2066     return;
2067   } else {
2068     jdimension = (int)dimension;
2069     swig_callbackOnCalculateRelayoutSize(jdimension);
2070   }
2071 }
2072
2073 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2074   float jsize  ;
2075   int jdimension  ;
2076
2077   if (!swig_callbackOnLayoutNegotiated) {
2078     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2079     return;
2080   } else {
2081     jsize = size;
2082     jdimension = (int)dimension;
2083     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2084   }
2085 }
2086
2087 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2088   return Dali::CustomActorImpl::GetExtension();
2089 }
2090
2091 void SwigDirector_ViewImpl::OnInitialize() {
2092   if (!swig_callbackOnInitialize) {
2093     Dali::Toolkit::Internal::Control::OnInitialize();
2094     return;
2095   } else {
2096     swig_callbackOnInitialize();
2097   }
2098 }
2099
2100 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2101   void * jstyleManager  ;
2102   int jchange  ;
2103
2104   if (!swig_callbackOnStyleChange) {
2105     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2106     return;
2107   } else {
2108     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2109     jchange = (int)change;
2110     swig_callbackOnStyleChange(jstyleManager, jchange);
2111   }
2112 }
2113
2114 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2115   bool c_result = SwigValueInit< bool >() ;
2116   unsigned int jresult = 0 ;
2117
2118   if (!swig_callbackOnAccessibilityActivated) {
2119     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2120   } else {
2121     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2122     c_result = jresult ? true : false;
2123   }
2124   return c_result;
2125 }
2126
2127 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2128   bool c_result = SwigValueInit< bool >() ;
2129   unsigned int jresult = 0 ;
2130   void * jgesture  ;
2131
2132   if (!swig_callbackOnAccessibilityPan) {
2133     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2134   } else {
2135     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2136     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2137     c_result = jresult ? true : false;
2138   }
2139   return c_result;
2140 }
2141
2142 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchData const &touchData) {
2143   bool c_result = SwigValueInit< bool >() ;
2144   unsigned int jresult = 0 ;
2145   void * jtouchData = 0 ;
2146
2147   if (!swig_callbackOnAccessibilityTouch) {
2148     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchData);
2149   } else {
2150     jtouchData = (Dali::TouchData *) &touchData;
2151     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchData);
2152     c_result = jresult ? true : false;
2153   }
2154   return c_result;
2155 }
2156
2157 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2158   bool c_result = SwigValueInit< bool >() ;
2159   unsigned int jresult = 0 ;
2160   unsigned int jisIncrease  ;
2161
2162   if (!swig_callbackOnAccessibilityValueChange) {
2163     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2164   } else {
2165     jisIncrease = isIncrease;
2166     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2167     c_result = jresult ? true : false;
2168   }
2169   return c_result;
2170 }
2171
2172 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2173   bool c_result = SwigValueInit< bool >() ;
2174   unsigned int jresult = 0 ;
2175
2176   if (!swig_callbackOnAccessibilityZoom) {
2177     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2178   } else {
2179     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2180     c_result = jresult ? true : false;
2181   }
2182   return c_result;
2183 }
2184
2185 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2186   if (!swig_callbackOnKeyInputFocusGained) {
2187     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2188     return;
2189   } else {
2190     swig_callbackOnKeyInputFocusGained();
2191   }
2192 }
2193
2194 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2195   if (!swig_callbackOnKeyInputFocusLost) {
2196     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2197     return;
2198   } else {
2199     swig_callbackOnKeyInputFocusLost();
2200   }
2201 }
2202
2203 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2204   Dali::Actor c_result ;
2205   void * jresult = 0 ;
2206   void * jcurrentFocusedActor  ;
2207   int jdirection  ;
2208   unsigned int jloopEnabled  ;
2209
2210   if (!swig_callbackGetNextKeyboardFocusableActor) {
2211     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2212   } else {
2213     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2214     jdirection = (int)direction;
2215     jloopEnabled = loopEnabled;
2216     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2217     if (!jresult) {
2218       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2219       return c_result;
2220     }
2221     c_result = *(Dali::Actor *)jresult;
2222   }
2223   return c_result;
2224 }
2225
2226 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2227   void * jcommitedFocusableActor  ;
2228
2229   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2230     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2231     return;
2232   } else {
2233     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2234     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2235   }
2236 }
2237
2238 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2239   bool c_result = SwigValueInit< bool >() ;
2240   unsigned int jresult = 0 ;
2241
2242   if (!swig_callbackOnKeyboardEnter) {
2243     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2244   } else {
2245     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2246     c_result = jresult ? true : false;
2247   }
2248   return c_result;
2249 }
2250
2251 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2252   void * jpinch = 0 ;
2253
2254   if (!swig_callbackOnPinch) {
2255     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2256     return;
2257   } else {
2258     jpinch = (Dali::PinchGesture *) &pinch;
2259     swig_callbackOnPinch(jpinch);
2260   }
2261 }
2262
2263 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2264   void * jpan = 0 ;
2265
2266   if (!swig_callbackOnPan) {
2267     Dali::Toolkit::Internal::Control::OnPan(pan);
2268     return;
2269   } else {
2270     jpan = (Dali::PanGesture *) &pan;
2271     swig_callbackOnPan(jpan);
2272   }
2273 }
2274
2275 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2276   void * jtap = 0 ;
2277
2278   if (!swig_callbackOnTap) {
2279     Dali::Toolkit::Internal::Control::OnTap(tap);
2280     return;
2281   } else {
2282     jtap = (Dali::TapGesture *) &tap;
2283     swig_callbackOnTap(jtap);
2284   }
2285 }
2286
2287 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2288   void * jlongPress = 0 ;
2289
2290   if (!swig_callbackOnLongPress) {
2291     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2292     return;
2293   } else {
2294     jlongPress = (Dali::LongPressGesture *) &longPress;
2295     swig_callbackOnLongPress(jlongPress);
2296   }
2297 }
2298
2299 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2300   void * jslotObserver = 0 ;
2301   void * jcallback = 0 ;
2302
2303   if (!swig_callbackSignalConnected) {
2304     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2305     return;
2306   } else {
2307     jslotObserver = (void *) slotObserver;
2308     jcallback = (void *) callback;
2309     swig_callbackSignalConnected(jslotObserver, jcallback);
2310   }
2311 }
2312
2313 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2314   void * jslotObserver = 0 ;
2315   void * jcallback = 0 ;
2316
2317   if (!swig_callbackSignalDisconnected) {
2318     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2319     return;
2320   } else {
2321     jslotObserver = (void *) slotObserver;
2322     jcallback = (void *) callback;
2323     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2324   }
2325 }
2326
2327 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2328   return Dali::Toolkit::Internal::Control::GetControlExtension();
2329 }
2330
2331 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_Callback27_t callbackOnAccessibilityTouch, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) {
2332   swig_callbackOnSceneConnection = callbackOnSceneConnection;
2333   swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection;
2334   swig_callbackOnChildAdd = callbackOnChildAdd;
2335   swig_callbackOnChildRemove = callbackOnChildRemove;
2336   swig_callbackOnPropertySet = callbackOnPropertySet;
2337   swig_callbackOnSizeSet = callbackOnSizeSet;
2338   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2339   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2340   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2341   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2342   swig_callbackOnRelayout = callbackOnRelayout;
2343   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2344   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2345   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2346   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2347   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2348   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2349   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2350   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2351   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2352   swig_callbackOnInitialize = callbackOnInitialize;
2353   swig_callbackOnStyleChange = callbackOnStyleChange;
2354   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2355   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2356   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2357   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2358   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2359   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2360   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2361   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2362   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2363   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2364   swig_callbackOnPinch = callbackOnPinch;
2365   swig_callbackOnPan = callbackOnPan;
2366   swig_callbackOnTap = callbackOnTap;
2367   swig_callbackOnLongPress = callbackOnLongPress;
2368   swig_callbackSignalConnected = callbackSignalConnected;
2369   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2370 }
2371
2372 void SwigDirector_ViewImpl::swig_init_callbacks() {
2373   swig_callbackOnSceneConnection = 0;
2374   swig_callbackOnSceneDisconnection = 0;
2375   swig_callbackOnChildAdd = 0;
2376   swig_callbackOnChildRemove = 0;
2377   swig_callbackOnPropertySet = 0;
2378   swig_callbackOnSizeSet = 0;
2379   swig_callbackOnSizeAnimation = 0;
2380   swig_callbackOnHoverEvent = 0;
2381   swig_callbackOnKeyEvent = 0;
2382   swig_callbackOnWheelEvent = 0;
2383   swig_callbackOnRelayout = 0;
2384   swig_callbackOnSetResizePolicy = 0;
2385   swig_callbackGetNaturalSize = 0;
2386   swig_callbackCalculateChildSize = 0;
2387   swig_callbackGetHeightForWidth = 0;
2388   swig_callbackGetWidthForHeight = 0;
2389   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2390   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2391   swig_callbackOnCalculateRelayoutSize = 0;
2392   swig_callbackOnLayoutNegotiated = 0;
2393   swig_callbackOnInitialize = 0;
2394   swig_callbackOnStyleChange = 0;
2395   swig_callbackOnAccessibilityActivated = 0;
2396   swig_callbackOnAccessibilityPan = 0;
2397   swig_callbackOnAccessibilityTouch = 0;
2398   swig_callbackOnAccessibilityValueChange = 0;
2399   swig_callbackOnAccessibilityZoom = 0;
2400   swig_callbackOnKeyInputFocusGained = 0;
2401   swig_callbackOnKeyInputFocusLost = 0;
2402   swig_callbackGetNextKeyboardFocusableActor = 0;
2403   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2404   swig_callbackOnKeyboardEnter = 0;
2405   swig_callbackOnPinch = 0;
2406   swig_callbackOnPan = 0;
2407   swig_callbackOnTap = 0;
2408   swig_callbackOnLongPress = 0;
2409   swig_callbackSignalConnected = 0;
2410   swig_callbackSignalDisconnected = 0;
2411 }
2412
2413 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2414   swig_init_callbacks();
2415 }
2416
2417 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2418
2419 }
2420
2421
2422 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2423   unsigned int c_result = SwigValueInit< unsigned int >() ;
2424   unsigned int jresult = 0 ;
2425
2426   if (!swig_callbackGetNumberOfItems) {
2427     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2428   } else {
2429     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2430     c_result = (unsigned int)jresult;
2431   }
2432   return c_result;
2433 }
2434
2435 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2436   Dali::Actor c_result ;
2437   void * jresult = 0 ;
2438   unsigned int jitemId  ;
2439
2440   if (!swig_callbackNewItem) {
2441     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2442   } else {
2443     jitemId = itemId;
2444     jresult = (void *) swig_callbackNewItem(jitemId);
2445     if (!jresult) {
2446       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2447       return c_result;
2448     }
2449     c_result = *(Dali::Actor *)jresult;
2450   }
2451   return c_result;
2452 }
2453
2454 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2455   unsigned int jitemId  ;
2456   void * jactor  ;
2457
2458   if (!swig_callbackItemReleased) {
2459     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2460     return;
2461   } else {
2462     jitemId = itemId;
2463     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2464     swig_callbackItemReleased(jitemId, jactor);
2465   }
2466 }
2467
2468 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2469   return Dali::Toolkit::ItemFactory::GetExtension();
2470 }
2471
2472 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2473   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2474   swig_callbackNewItem = callbackNewItem;
2475   swig_callbackItemReleased = callbackItemReleased;
2476 }
2477
2478 void SwigDirector_ItemFactory::swig_init_callbacks() {
2479   swig_callbackGetNumberOfItems = 0;
2480   swig_callbackNewItem = 0;
2481   swig_callbackItemReleased = 0;
2482 }
2483
2484 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2485   swig_init_callbacks();
2486 }
2487
2488 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2489
2490 }
2491
2492
2493 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2494   Dali::Actor c_result ;
2495   void * jresult = 0 ;
2496   void * jcurrent  ;
2497   void * jproposed  ;
2498   int jdirection  ;
2499
2500   if (!swig_callbackGetNextFocusableActor) {
2501     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2502   } else {
2503     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2504     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2505     jdirection = (int)direction;
2506     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2507     if (!jresult) {
2508       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__);
2509       return c_result;
2510     }
2511     c_result = *(Dali::Actor *)jresult;
2512   }
2513   return c_result;
2514 }
2515
2516 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2517   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2518 }
2519
2520 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2521   swig_callbackGetNextFocusableActor = 0;
2522 }
2523
2524 SwigDirector_FrameCallbackInterface::SwigDirector_FrameCallbackInterface() : Dali::FrameCallbackInterface(), Swig::Director() {
2525   swig_callbackOnUpdate = 0;
2526 }
2527
2528 SwigDirector_FrameCallbackInterface::~SwigDirector_FrameCallbackInterface() {
2529
2530 }
2531
2532 void SwigDirector_FrameCallbackInterface::swig_connect_director(SWIG_Callback0_t callbackUpdate) {
2533   swig_callbackOnUpdate = callbackUpdate;
2534 }
2535
2536
2537 void SwigDirector_FrameCallbackInterface::Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) {
2538   void * jcurrent  ;
2539
2540   if (!swig_callbackOnUpdate) {
2541     throw Swig::DirectorPureVirtualException("Dali::FrameCallbackInterface::Update");
2542   } else {
2543     Dali::UpdateProxy* proxy = &updateProxy;
2544     jcurrent = (void *)proxy;
2545     swig_callbackOnUpdate(jcurrent, elapsedSeconds);
2546     if (!jcurrent) {
2547       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::UpdateProxy! ", __FILE__, __LINE__);
2548       return;
2549     }
2550   }
2551   return;
2552 }
2553
2554
2555 #ifdef __cplusplus
2556 extern "C" {
2557 #endif
2558
2559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2560   void * jresult ;
2561   floatp *result = 0 ;
2562
2563   {
2564     try {
2565       result = (floatp *)new_floatp();
2566     } catch (std::out_of_range& e) {
2567       {
2568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2569       };
2570     } catch (std::exception& e) {
2571       {
2572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2573       };
2574     } catch (DaliException e) {
2575       {
2576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2577       };
2578     } catch (...) {
2579       {
2580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2581       };
2582     }
2583   }
2584   jresult = (void *)result;
2585   return jresult;
2586 }
2587
2588
2589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2590   floatp *arg1 = (floatp *) 0 ;
2591
2592   arg1 = (floatp *)jarg1;
2593   {
2594     try {
2595       delete_floatp(arg1);
2596     } catch (std::out_of_range& e) {
2597       {
2598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2599       };
2600     } catch (std::exception& e) {
2601       {
2602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2603       };
2604     } catch (Dali::DaliException e) {
2605       {
2606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2607       };
2608     } catch (...) {
2609       {
2610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2611       };
2612     }
2613   }
2614
2615 }
2616
2617
2618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2619   floatp *arg1 = (floatp *) 0 ;
2620   float arg2 ;
2621
2622   arg1 = (floatp *)jarg1;
2623   arg2 = (float)jarg2;
2624   {
2625     try {
2626       floatp_assign(arg1,arg2);
2627     } catch (std::out_of_range& e) {
2628       {
2629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2630       };
2631     } catch (std::exception& e) {
2632       {
2633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2634       };
2635     } catch (Dali::DaliException e) {
2636       {
2637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2638       };
2639     } catch (...) {
2640       {
2641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2642       };
2643     }
2644   }
2645
2646 }
2647
2648
2649 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2650   float jresult ;
2651   floatp *arg1 = (floatp *) 0 ;
2652   float result;
2653
2654   arg1 = (floatp *)jarg1;
2655   {
2656     try {
2657       result = (float)floatp_value(arg1);
2658     } catch (std::out_of_range& e) {
2659       {
2660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2661       };
2662     } catch (std::exception& e) {
2663       {
2664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2665       };
2666     } catch (DaliException e) {
2667       {
2668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2669       };
2670     } catch (...) {
2671       {
2672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2673       };
2674     }
2675   }
2676   jresult = result;
2677   return jresult;
2678 }
2679
2680
2681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2682   void * jresult ;
2683   floatp *arg1 = (floatp *) 0 ;
2684   float *result = 0 ;
2685
2686   arg1 = (floatp *)jarg1;
2687   {
2688     try {
2689       result = (float *)floatp_cast(arg1);
2690     } catch (std::out_of_range& e) {
2691       {
2692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2693       };
2694     } catch (std::exception& e) {
2695       {
2696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2697       };
2698     } catch (Dali::DaliException e) {
2699       {
2700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2701       };
2702     } catch (...) {
2703       {
2704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2705       };
2706     }
2707   }
2708
2709   jresult = (void *)result;
2710   return jresult;
2711 }
2712
2713
2714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2715   void * jresult ;
2716   float *arg1 = (float *) 0 ;
2717   floatp *result = 0 ;
2718
2719   arg1 = (float *)jarg1;
2720   {
2721     try {
2722       result = (floatp *)floatp_frompointer(arg1);
2723     } catch (std::out_of_range& e) {
2724       {
2725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2726       };
2727     } catch (std::exception& e) {
2728       {
2729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2730       };
2731     } catch (Dali::DaliException e) {
2732       {
2733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2734       };
2735     } catch (...) {
2736       {
2737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2738       };
2739     }
2740   }
2741
2742   jresult = (void *)result;
2743   return jresult;
2744 }
2745
2746
2747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2748   void * jresult ;
2749   intp *result = 0 ;
2750
2751   {
2752     try {
2753       result = (intp *)new_intp();
2754     } catch (std::out_of_range& e) {
2755       {
2756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2757       };
2758     } catch (std::exception& e) {
2759       {
2760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2761       };
2762     } catch (Dali::DaliException e) {
2763       {
2764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2765       };
2766     } catch (...) {
2767       {
2768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2769       };
2770     }
2771   }
2772
2773   jresult = (void *)result;
2774   return jresult;
2775 }
2776
2777
2778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2779   intp *arg1 = (intp *) 0 ;
2780
2781   arg1 = (intp *)jarg1;
2782   {
2783     try {
2784       delete_intp(arg1);
2785     } catch (std::out_of_range& e) {
2786       {
2787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2788       };
2789     } catch (std::exception& e) {
2790       {
2791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2792       };
2793     } catch (Dali::DaliException e) {
2794       {
2795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2796       };
2797     } catch (...) {
2798       {
2799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2800       };
2801     }
2802   }
2803
2804 }
2805
2806
2807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2808   intp *arg1 = (intp *) 0 ;
2809   int arg2 ;
2810
2811   arg1 = (intp *)jarg1;
2812   arg2 = (int)jarg2;
2813   {
2814     try {
2815       intp_assign(arg1,arg2);
2816     } catch (std::out_of_range& e) {
2817       {
2818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2819       };
2820     } catch (std::exception& e) {
2821       {
2822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2823       };
2824     } catch (Dali::DaliException e) {
2825       {
2826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2827       };
2828     } catch (...) {
2829       {
2830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2831       };
2832     }
2833   }
2834
2835 }
2836
2837
2838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2839   int jresult ;
2840   intp *arg1 = (intp *) 0 ;
2841   int result;
2842
2843   arg1 = (intp *)jarg1;
2844   {
2845     try {
2846       result = (int)intp_value(arg1);
2847     } catch (std::out_of_range& e) {
2848       {
2849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2850       };
2851     } catch (std::exception& e) {
2852       {
2853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2854       };
2855     } catch (Dali::DaliException e) {
2856       {
2857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2858       };
2859     } catch (...) {
2860       {
2861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2862       };
2863     }
2864   }
2865
2866   jresult = result;
2867   return jresult;
2868 }
2869
2870
2871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2872   void * jresult ;
2873   intp *arg1 = (intp *) 0 ;
2874   int *result = 0 ;
2875
2876   arg1 = (intp *)jarg1;
2877   {
2878     try {
2879       result = (int *)intp_cast(arg1);
2880     } catch (std::out_of_range& e) {
2881       {
2882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2883       };
2884     } catch (std::exception& e) {
2885       {
2886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2887       };
2888     } catch (Dali::DaliException e) {
2889       {
2890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2891       };
2892     } catch (...) {
2893       {
2894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2895       };
2896     }
2897   }
2898
2899   jresult = (void *)result;
2900   return jresult;
2901 }
2902
2903
2904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2905   void * jresult ;
2906   int *arg1 = (int *) 0 ;
2907   intp *result = 0 ;
2908
2909   arg1 = (int *)jarg1;
2910   {
2911     try {
2912       result = (intp *)intp_frompointer(arg1);
2913     } catch (std::out_of_range& e) {
2914       {
2915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2916       };
2917     } catch (std::exception& e) {
2918       {
2919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2920       };
2921     } catch (Dali::DaliException e) {
2922       {
2923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2924       };
2925     } catch (...) {
2926       {
2927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2928       };
2929     }
2930   }
2931
2932   jresult = (void *)result;
2933   return jresult;
2934 }
2935
2936
2937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2938   void * jresult ;
2939   doublep *result = 0 ;
2940
2941   {
2942     try {
2943       result = (doublep *)new_doublep();
2944     } catch (std::out_of_range& e) {
2945       {
2946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2947       };
2948     } catch (std::exception& e) {
2949       {
2950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2951       };
2952     } catch (Dali::DaliException e) {
2953       {
2954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2955       };
2956     } catch (...) {
2957       {
2958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2959       };
2960     }
2961   }
2962
2963   jresult = (void *)result;
2964   return jresult;
2965 }
2966
2967
2968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2969   doublep *arg1 = (doublep *) 0 ;
2970
2971   arg1 = (doublep *)jarg1;
2972   {
2973     try {
2974       delete_doublep(arg1);
2975     } catch (std::out_of_range& e) {
2976       {
2977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2978       };
2979     } catch (std::exception& e) {
2980       {
2981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2982       };
2983     } catch (Dali::DaliException e) {
2984       {
2985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2986       };
2987     } catch (...) {
2988       {
2989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2990       };
2991     }
2992   }
2993
2994 }
2995
2996
2997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2998   doublep *arg1 = (doublep *) 0 ;
2999   double arg2 ;
3000
3001   arg1 = (doublep *)jarg1;
3002   arg2 = (double)jarg2;
3003   {
3004     try {
3005       doublep_assign(arg1,arg2);
3006     } catch (std::out_of_range& e) {
3007       {
3008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3009       };
3010     } catch (std::exception& e) {
3011       {
3012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3013       };
3014     } catch (Dali::DaliException e) {
3015       {
3016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3017       };
3018     } catch (...) {
3019       {
3020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3021       };
3022     }
3023   }
3024
3025 }
3026
3027
3028 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3029   double jresult ;
3030   doublep *arg1 = (doublep *) 0 ;
3031   double result;
3032
3033   arg1 = (doublep *)jarg1;
3034   {
3035     try {
3036       result = (double)doublep_value(arg1);
3037     } catch (std::out_of_range& e) {
3038       {
3039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3040       };
3041     } catch (std::exception& e) {
3042       {
3043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3044       };
3045     } catch (Dali::DaliException e) {
3046       {
3047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3048       };
3049     } catch (...) {
3050       {
3051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3052       };
3053     }
3054   }
3055
3056   jresult = result;
3057   return jresult;
3058 }
3059
3060
3061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3062   void * jresult ;
3063   doublep *arg1 = (doublep *) 0 ;
3064   double *result = 0 ;
3065
3066   arg1 = (doublep *)jarg1;
3067   {
3068     try {
3069       result = (double *)doublep_cast(arg1);
3070     } catch (std::out_of_range& e) {
3071       {
3072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3073       };
3074     } catch (std::exception& e) {
3075       {
3076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3077       };
3078     } catch (Dali::DaliException e) {
3079       {
3080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3081       };
3082     } catch (...) {
3083       {
3084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3085       };
3086     }
3087   }
3088
3089   jresult = (void *)result;
3090   return jresult;
3091 }
3092
3093
3094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3095   void * jresult ;
3096   double *arg1 = (double *) 0 ;
3097   doublep *result = 0 ;
3098
3099   arg1 = (double *)jarg1;
3100   {
3101     try {
3102       result = (doublep *)doublep_frompointer(arg1);
3103     } catch (std::out_of_range& e) {
3104       {
3105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3106       };
3107     } catch (std::exception& e) {
3108       {
3109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3110       };
3111     } catch (Dali::DaliException e) {
3112       {
3113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3114       };
3115     } catch (...) {
3116       {
3117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3118       };
3119     }
3120   }
3121
3122   jresult = (void *)result;
3123   return jresult;
3124 }
3125
3126
3127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3128   void * jresult ;
3129   uintp *result = 0 ;
3130
3131   {
3132     try {
3133       result = (uintp *)new_uintp();
3134     } catch (std::out_of_range& e) {
3135       {
3136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3137       };
3138     } catch (std::exception& e) {
3139       {
3140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3141       };
3142     } catch (Dali::DaliException e) {
3143       {
3144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3145       };
3146     } catch (...) {
3147       {
3148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3149       };
3150     }
3151   }
3152
3153   jresult = (void *)result;
3154   return jresult;
3155 }
3156
3157
3158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3159   uintp *arg1 = (uintp *) 0 ;
3160
3161   arg1 = (uintp *)jarg1;
3162   {
3163     try {
3164       delete_uintp(arg1);
3165     } catch (std::out_of_range& e) {
3166       {
3167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3168       };
3169     } catch (std::exception& e) {
3170       {
3171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3172       };
3173     } catch (Dali::DaliException e) {
3174       {
3175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3176       };
3177     } catch (...) {
3178       {
3179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3180       };
3181     }
3182   }
3183
3184 }
3185
3186
3187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3188   uintp *arg1 = (uintp *) 0 ;
3189   unsigned int arg2 ;
3190
3191   arg1 = (uintp *)jarg1;
3192   arg2 = (unsigned int)jarg2;
3193   {
3194     try {
3195       uintp_assign(arg1,arg2);
3196     } catch (std::out_of_range& e) {
3197       {
3198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3199       };
3200     } catch (std::exception& e) {
3201       {
3202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3203       };
3204     } catch (Dali::DaliException e) {
3205       {
3206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3207       };
3208     } catch (...) {
3209       {
3210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3211       };
3212     }
3213   }
3214
3215 }
3216
3217
3218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3219   unsigned int jresult ;
3220   uintp *arg1 = (uintp *) 0 ;
3221   unsigned int result;
3222
3223   arg1 = (uintp *)jarg1;
3224   {
3225     try {
3226       result = (unsigned int)uintp_value(arg1);
3227     } catch (std::out_of_range& e) {
3228       {
3229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3230       };
3231     } catch (std::exception& e) {
3232       {
3233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3234       };
3235     } catch (Dali::DaliException e) {
3236       {
3237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3238       };
3239     } catch (...) {
3240       {
3241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3242       };
3243     }
3244   }
3245
3246   jresult = result;
3247   return jresult;
3248 }
3249
3250
3251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3252   void * jresult ;
3253   uintp *arg1 = (uintp *) 0 ;
3254   unsigned int *result = 0 ;
3255
3256   arg1 = (uintp *)jarg1;
3257   {
3258     try {
3259       result = (unsigned int *)uintp_cast(arg1);
3260     } catch (std::out_of_range& e) {
3261       {
3262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3263       };
3264     } catch (std::exception& e) {
3265       {
3266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3267       };
3268     } catch (Dali::DaliException e) {
3269       {
3270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3271       };
3272     } catch (...) {
3273       {
3274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3275       };
3276     }
3277   }
3278
3279   jresult = (void *)result;
3280   return jresult;
3281 }
3282
3283
3284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3285   void * jresult ;
3286   unsigned int *arg1 = (unsigned int *) 0 ;
3287   uintp *result = 0 ;
3288
3289   arg1 = (unsigned int *)jarg1;
3290   {
3291     try {
3292       result = (uintp *)uintp_frompointer(arg1);
3293     } catch (std::out_of_range& e) {
3294       {
3295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3296       };
3297     } catch (std::exception& e) {
3298       {
3299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3300       };
3301     } catch (Dali::DaliException e) {
3302       {
3303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3304       };
3305     } catch (...) {
3306       {
3307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3308       };
3309     }
3310   }
3311
3312   jresult = (void *)result;
3313   return jresult;
3314 }
3315
3316
3317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3318   void * jresult ;
3319   ushortp *result = 0 ;
3320
3321   {
3322     try {
3323       result = (ushortp *)new_ushortp();
3324     } catch (std::out_of_range& e) {
3325       {
3326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3327       };
3328     } catch (std::exception& e) {
3329       {
3330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3331       };
3332     } catch (Dali::DaliException e) {
3333       {
3334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3335       };
3336     } catch (...) {
3337       {
3338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3339       };
3340     }
3341   }
3342
3343   jresult = (void *)result;
3344   return jresult;
3345 }
3346
3347
3348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3349   ushortp *arg1 = (ushortp *) 0 ;
3350
3351   arg1 = (ushortp *)jarg1;
3352   {
3353     try {
3354       delete_ushortp(arg1);
3355     } catch (std::out_of_range& e) {
3356       {
3357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3358       };
3359     } catch (std::exception& e) {
3360       {
3361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3362       };
3363     } catch (Dali::DaliException e) {
3364       {
3365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3366       };
3367     } catch (...) {
3368       {
3369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3370       };
3371     }
3372   }
3373
3374 }
3375
3376
3377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3378   ushortp *arg1 = (ushortp *) 0 ;
3379   unsigned short arg2 ;
3380
3381   arg1 = (ushortp *)jarg1;
3382   arg2 = (unsigned short)jarg2;
3383   {
3384     try {
3385       ushortp_assign(arg1,arg2);
3386     } catch (std::out_of_range& e) {
3387       {
3388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3389       };
3390     } catch (std::exception& e) {
3391       {
3392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3393       };
3394     } catch (Dali::DaliException e) {
3395       {
3396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3397       };
3398     } catch (...) {
3399       {
3400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3401       };
3402     }
3403   }
3404
3405 }
3406
3407
3408 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3409   unsigned short jresult ;
3410   ushortp *arg1 = (ushortp *) 0 ;
3411   unsigned short result;
3412
3413   arg1 = (ushortp *)jarg1;
3414   {
3415     try {
3416       result = (unsigned short)ushortp_value(arg1);
3417     } catch (std::out_of_range& e) {
3418       {
3419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3420       };
3421     } catch (std::exception& e) {
3422       {
3423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3424       };
3425     } catch (Dali::DaliException e) {
3426       {
3427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3428       };
3429     } catch (...) {
3430       {
3431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3432       };
3433     }
3434   }
3435
3436   jresult = result;
3437   return jresult;
3438 }
3439
3440
3441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3442   void * jresult ;
3443   ushortp *arg1 = (ushortp *) 0 ;
3444   unsigned short *result = 0 ;
3445
3446   arg1 = (ushortp *)jarg1;
3447   {
3448     try {
3449       result = (unsigned short *)ushortp_cast(arg1);
3450     } catch (std::out_of_range& e) {
3451       {
3452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3453       };
3454     } catch (std::exception& e) {
3455       {
3456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3457       };
3458     } catch (Dali::DaliException e) {
3459       {
3460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3461       };
3462     } catch (...) {
3463       {
3464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3465       };
3466     }
3467   }
3468
3469   jresult = (void *)result;
3470   return jresult;
3471 }
3472
3473
3474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3475   void * jresult ;
3476   unsigned short *arg1 = (unsigned short *) 0 ;
3477   ushortp *result = 0 ;
3478
3479   arg1 = (unsigned short *)jarg1;
3480   {
3481     try {
3482       result = (ushortp *)ushortp_frompointer(arg1);
3483     } catch (std::out_of_range& e) {
3484       {
3485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3486       };
3487     } catch (std::exception& e) {
3488       {
3489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3490       };
3491     } catch (Dali::DaliException e) {
3492       {
3493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3494       };
3495     } catch (...) {
3496       {
3497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3498       };
3499     }
3500   }
3501
3502   jresult = (void *)result;
3503   return jresult;
3504 }
3505
3506
3507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3508   unsigned int jresult ;
3509   int arg1 ;
3510   unsigned int result;
3511
3512   arg1 = (int)jarg1;
3513   {
3514     try {
3515       result = (unsigned int)int_to_uint(arg1);
3516     } catch (std::out_of_range& e) {
3517       {
3518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3519       };
3520     } catch (std::exception& e) {
3521       {
3522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3523       };
3524     } catch (Dali::DaliException e) {
3525       {
3526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3527       };
3528     } catch (...) {
3529       {
3530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3531       };
3532     }
3533   }
3534
3535   jresult = result;
3536   return jresult;
3537 }
3538
3539
3540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3541   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3542
3543   arg1 = (Dali::RefObject *)jarg1;
3544   {
3545     try {
3546       (arg1)->Reference();
3547     } catch (std::out_of_range& e) {
3548       {
3549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3550       };
3551     } catch (std::exception& e) {
3552       {
3553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3554       };
3555     } catch (Dali::DaliException e) {
3556       {
3557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3558       };
3559     } catch (...) {
3560       {
3561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3562       };
3563     }
3564   }
3565
3566 }
3567
3568
3569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3570   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3571
3572   arg1 = (Dali::RefObject *)jarg1;
3573   {
3574     try {
3575       (arg1)->Unreference();
3576     } catch (std::out_of_range& e) {
3577       {
3578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3579       };
3580     } catch (std::exception& e) {
3581       {
3582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3583       };
3584     } catch (Dali::DaliException e) {
3585       {
3586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3587       };
3588     } catch (...) {
3589       {
3590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3591       };
3592     }
3593   }
3594
3595 }
3596
3597
3598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3599   int jresult ;
3600   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3601   int result;
3602
3603   arg1 = (Dali::RefObject *)jarg1;
3604   {
3605     try {
3606       result = (int)(arg1)->ReferenceCount();
3607     } catch (std::out_of_range& e) {
3608       {
3609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3610       };
3611     } catch (std::exception& e) {
3612       {
3613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3614       };
3615     } catch (Dali::DaliException e) {
3616       {
3617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3618       };
3619     } catch (...) {
3620       {
3621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3622       };
3623     }
3624   }
3625
3626   jresult = result;
3627   return jresult;
3628 }
3629
3630
3631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3632   void * jresult ;
3633   Dali::Any *result = 0 ;
3634
3635   {
3636     try {
3637       result = (Dali::Any *)new Dali::Any();
3638     } catch (std::out_of_range& e) {
3639       {
3640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3641       };
3642     } catch (std::exception& e) {
3643       {
3644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3645       };
3646     } catch (Dali::DaliException e) {
3647       {
3648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3649       };
3650     } catch (...) {
3651       {
3652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3653       };
3654     }
3655   }
3656
3657   jresult = (void *)result;
3658   return jresult;
3659 }
3660
3661
3662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3663   Dali::Any *arg1 = (Dali::Any *) 0 ;
3664
3665   arg1 = (Dali::Any *)jarg1;
3666   {
3667     try {
3668       delete arg1;
3669     } catch (std::out_of_range& e) {
3670       {
3671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3672       };
3673     } catch (std::exception& e) {
3674       {
3675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3676       };
3677     } catch (Dali::DaliException e) {
3678       {
3679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3680       };
3681     } catch (...) {
3682       {
3683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3684       };
3685     }
3686   }
3687
3688 }
3689
3690
3691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3692   char *arg1 = (char *) 0 ;
3693
3694   arg1 = (char *)jarg1;
3695   {
3696     try {
3697       Dali::Any::AssertAlways((char const *)arg1);
3698     } catch (std::out_of_range& e) {
3699       {
3700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3701       };
3702     } catch (std::exception& e) {
3703       {
3704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3705       };
3706     } catch (Dali::DaliException e) {
3707       {
3708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3709       };
3710     } catch (...) {
3711       {
3712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3713       };
3714     }
3715   }
3716
3717 }
3718
3719
3720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3721   void * jresult ;
3722   Dali::Any *arg1 = 0 ;
3723   Dali::Any *result = 0 ;
3724
3725   arg1 = (Dali::Any *)jarg1;
3726   if (!arg1) {
3727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3728     return 0;
3729   }
3730   {
3731     try {
3732       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3733     } catch (std::out_of_range& e) {
3734       {
3735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3736       };
3737     } catch (std::exception& e) {
3738       {
3739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3740       };
3741     } catch (Dali::DaliException e) {
3742       {
3743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3744       };
3745     } catch (...) {
3746       {
3747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3748       };
3749     }
3750   }
3751
3752   jresult = (void *)result;
3753   return jresult;
3754 }
3755
3756
3757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3758   void * jresult ;
3759   Dali::Any *arg1 = (Dali::Any *) 0 ;
3760   Dali::Any *arg2 = 0 ;
3761   Dali::Any *result = 0 ;
3762
3763   arg1 = (Dali::Any *)jarg1;
3764   arg2 = (Dali::Any *)jarg2;
3765   if (!arg2) {
3766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3767     return 0;
3768   }
3769   {
3770     try {
3771       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3772     } catch (std::out_of_range& e) {
3773       {
3774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3775       };
3776     } catch (std::exception& e) {
3777       {
3778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3779       };
3780     } catch (Dali::DaliException e) {
3781       {
3782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3783       };
3784     } catch (...) {
3785       {
3786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3787       };
3788     }
3789   }
3790
3791   jresult = (void *)result;
3792   return jresult;
3793 }
3794
3795
3796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3797   void * jresult ;
3798   Dali::Any *arg1 = (Dali::Any *) 0 ;
3799   std::type_info *result = 0 ;
3800
3801   arg1 = (Dali::Any *)jarg1;
3802   {
3803     try {
3804       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3805     } catch (std::out_of_range& e) {
3806       {
3807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3808       };
3809     } catch (std::exception& e) {
3810       {
3811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3812       };
3813     } catch (Dali::DaliException e) {
3814       {
3815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3816       };
3817     } catch (...) {
3818       {
3819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3820       };
3821     }
3822   }
3823
3824   jresult = (void *)result;
3825   return jresult;
3826 }
3827
3828
3829 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3830   unsigned int jresult ;
3831   Dali::Any *arg1 = (Dali::Any *) 0 ;
3832   bool result;
3833
3834   arg1 = (Dali::Any *)jarg1;
3835   {
3836     try {
3837       result = (bool)((Dali::Any const *)arg1)->Empty();
3838     } catch (std::out_of_range& e) {
3839       {
3840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3841       };
3842     } catch (std::exception& e) {
3843       {
3844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3845       };
3846     } catch (Dali::DaliException e) {
3847       {
3848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3849       };
3850     } catch (...) {
3851       {
3852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3853       };
3854     }
3855   }
3856
3857   jresult = result;
3858   return jresult;
3859 }
3860
3861
3862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3863   void * jresult ;
3864   std::type_info *arg1 = 0 ;
3865   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3866   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3867   Dali::Any::AnyContainerBase *result = 0 ;
3868
3869   arg1 = (std::type_info *)jarg1;
3870   if (!arg1) {
3871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3872     return 0;
3873   }
3874   arg2 = (Dali::Any::CloneFunc)jarg2;
3875   arg3 = (Dali::Any::DeleteFunc)jarg3;
3876   {
3877     try {
3878       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3879     } catch (std::out_of_range& e) {
3880       {
3881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3882       };
3883     } catch (std::exception& e) {
3884       {
3885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3886       };
3887     } catch (Dali::DaliException e) {
3888       {
3889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3890       };
3891     } catch (...) {
3892       {
3893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3894       };
3895     }
3896   }
3897
3898   jresult = (void *)result;
3899   return jresult;
3900 }
3901
3902
3903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3904   void * jresult ;
3905   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3906   std::type_info *result = 0 ;
3907
3908   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3909   {
3910     try {
3911       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3912     } catch (std::out_of_range& e) {
3913       {
3914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3915       };
3916     } catch (std::exception& e) {
3917       {
3918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3919       };
3920     } catch (Dali::DaliException e) {
3921       {
3922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3923       };
3924     } catch (...) {
3925       {
3926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3927       };
3928     }
3929   }
3930
3931   jresult = (void *)result;
3932   return jresult;
3933 }
3934
3935
3936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3937   void * jresult ;
3938   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3939   ::std::type_info *result = 0 ;
3940
3941   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3942   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3943   jresult = (void *)result;
3944   return jresult;
3945 }
3946
3947
3948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3949   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3950   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3951
3952   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3953   arg2 = (Dali::Any::CloneFunc)jarg2;
3954   if (arg1) (arg1)->mCloneFunc = arg2;
3955 }
3956
3957
3958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3959   void * jresult ;
3960   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3961   Dali::Any::CloneFunc result;
3962
3963   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3964   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3965   jresult = (void *)result;
3966   return jresult;
3967 }
3968
3969
3970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3971   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3972   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3973
3974   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3975   arg2 = (Dali::Any::DeleteFunc)jarg2;
3976   if (arg1) (arg1)->mDeleteFunc = arg2;
3977 }
3978
3979
3980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3981   void * jresult ;
3982   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3983   Dali::Any::DeleteFunc result;
3984
3985   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3986   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3987   jresult = (void *)result;
3988   return jresult;
3989 }
3990
3991
3992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3993   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3994
3995   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3996   {
3997     try {
3998       delete arg1;
3999     } catch (std::out_of_range& e) {
4000       {
4001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4002       };
4003     } catch (std::exception& e) {
4004       {
4005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4006       };
4007     } catch (Dali::DaliException e) {
4008       {
4009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4010       };
4011     } catch (...) {
4012       {
4013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4014       };
4015     }
4016   }
4017
4018 }
4019
4020
4021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4022   Dali::Any *arg1 = (Dali::Any *) 0 ;
4023   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4024
4025   arg1 = (Dali::Any *)jarg1;
4026   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4027   if (arg1) (arg1)->mContainer = arg2;
4028 }
4029
4030
4031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4032   void * jresult ;
4033   Dali::Any *arg1 = (Dali::Any *) 0 ;
4034   Dali::Any::AnyContainerBase *result = 0 ;
4035
4036   arg1 = (Dali::Any *)jarg1;
4037   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4038   jresult = (void *)result;
4039   return jresult;
4040 }
4041
4042
4043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4044   char *arg1 = (char *) 0 ;
4045   char *arg2 = (char *) 0 ;
4046
4047   arg1 = (char *)jarg1;
4048   arg2 = (char *)jarg2;
4049   {
4050     try {
4051       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4052     } catch (std::out_of_range& e) {
4053       {
4054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4055       };
4056     } catch (std::exception& e) {
4057       {
4058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4059       };
4060     } catch (Dali::DaliException e) {
4061       {
4062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4063       };
4064     } catch (...) {
4065       {
4066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4067       };
4068     }
4069   }
4070
4071 }
4072
4073
4074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4075   void * jresult ;
4076   char *arg1 = (char *) 0 ;
4077   char *arg2 = (char *) 0 ;
4078   Dali::DaliException *result = 0 ;
4079
4080   arg1 = (char *)jarg1;
4081   arg2 = (char *)jarg2;
4082   {
4083     try {
4084       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4085     } catch (std::out_of_range& e) {
4086       {
4087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4088       };
4089     } catch (std::exception& e) {
4090       {
4091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4092       };
4093     } catch (Dali::DaliException e) {
4094       {
4095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4096       };
4097     } catch (...) {
4098       {
4099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4100       };
4101     }
4102   }
4103
4104   jresult = (void *)result;
4105   return jresult;
4106 }
4107
4108
4109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4110   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4111   std::string arg2 = std::string(jarg2);
4112
4113   arg1 = (Dali::DaliException *)jarg1;
4114   {
4115     if (!arg2.empty()) {
4116       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4117     } else {
4118       arg1->location = 0;
4119     }
4120   }
4121 }
4122
4123 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4124   char * jresult ;
4125   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4126   char *result = 0 ;
4127
4128   arg1 = (Dali::DaliException *)jarg1;
4129   result = (char *) ((arg1)->location);
4130   jresult = SWIG_csharp_string_callback((const char *)result);
4131   return jresult;
4132 }
4133
4134
4135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4136   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4137   std::string arg2 = std::string(jarg2);
4138
4139   arg1 = (Dali::DaliException *)jarg1;
4140   {
4141     if (!arg2.empty()) {
4142       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4143     } else {
4144       arg1->condition = 0;
4145     }
4146   }
4147 }
4148
4149
4150 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4151   char * jresult ;
4152   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4153   char *result = 0 ;
4154
4155   arg1 = (Dali::DaliException *)jarg1;
4156   result = (char *) ((arg1)->condition);
4157   jresult = SWIG_csharp_string_callback((const char *)result);
4158   return jresult;
4159 }
4160
4161
4162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4163   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4164
4165   arg1 = (Dali::DaliException *)jarg1;
4166   {
4167     try {
4168       delete arg1;
4169     } catch (std::out_of_range& e) {
4170       {
4171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4172       };
4173     } catch (std::exception& e) {
4174       {
4175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4176       };
4177     } catch (Dali::DaliException e) {
4178       {
4179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4180       };
4181     } catch (...) {
4182       {
4183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4184       };
4185     }
4186   }
4187
4188 }
4189
4190
4191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4192   void * jresult ;
4193   Dali::Vector2 *result = 0 ;
4194
4195   {
4196     try {
4197       result = (Dali::Vector2 *)new Dali::Vector2();
4198     } catch (std::out_of_range& e) {
4199       {
4200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4201       };
4202     } catch (std::exception& e) {
4203       {
4204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4205       };
4206     } catch (Dali::DaliException e) {
4207       {
4208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4209       };
4210     } catch (...) {
4211       {
4212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4213       };
4214     }
4215   }
4216
4217   jresult = (void *)result;
4218   return jresult;
4219 }
4220
4221
4222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4223   void * jresult ;
4224   float arg1 ;
4225   float arg2 ;
4226   Dali::Vector2 *result = 0 ;
4227
4228   arg1 = (float)jarg1;
4229   arg2 = (float)jarg2;
4230   {
4231     try {
4232       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4233     } catch (std::out_of_range& e) {
4234       {
4235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4236       };
4237     } catch (std::exception& e) {
4238       {
4239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4240       };
4241     } catch (Dali::DaliException e) {
4242       {
4243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4244       };
4245     } catch (...) {
4246       {
4247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4248       };
4249     }
4250   }
4251
4252   jresult = (void *)result;
4253   return jresult;
4254 }
4255
4256
4257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4258   void * jresult ;
4259   float *arg1 = (float *) 0 ;
4260   Dali::Vector2 *result = 0 ;
4261
4262   arg1 = jarg1;
4263   {
4264     try {
4265       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4266     } catch (std::out_of_range& e) {
4267       {
4268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4269       };
4270     } catch (std::exception& e) {
4271       {
4272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4273       };
4274     } catch (Dali::DaliException e) {
4275       {
4276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4277       };
4278     } catch (...) {
4279       {
4280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4281       };
4282     }
4283   }
4284
4285   jresult = (void *)result;
4286
4287
4288   return jresult;
4289 }
4290
4291
4292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4293   void * jresult ;
4294   Dali::Vector3 *arg1 = 0 ;
4295   Dali::Vector2 *result = 0 ;
4296
4297   arg1 = (Dali::Vector3 *)jarg1;
4298   if (!arg1) {
4299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4300     return 0;
4301   }
4302   {
4303     try {
4304       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4305     } catch (std::out_of_range& e) {
4306       {
4307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4308       };
4309     } catch (std::exception& e) {
4310       {
4311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4312       };
4313     } catch (Dali::DaliException e) {
4314       {
4315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4316       };
4317     } catch (...) {
4318       {
4319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4320       };
4321     }
4322   }
4323
4324   jresult = (void *)result;
4325   return jresult;
4326 }
4327
4328
4329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4330   void * jresult ;
4331   Dali::Vector4 *arg1 = 0 ;
4332   Dali::Vector2 *result = 0 ;
4333
4334   arg1 = (Dali::Vector4 *)jarg1;
4335   if (!arg1) {
4336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4337     return 0;
4338   }
4339   {
4340     try {
4341       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4342     } catch (std::out_of_range& e) {
4343       {
4344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4345       };
4346     } catch (std::exception& e) {
4347       {
4348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4349       };
4350     } catch (Dali::DaliException e) {
4351       {
4352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4353       };
4354     } catch (...) {
4355       {
4356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4357       };
4358     }
4359   }
4360
4361   jresult = (void *)result;
4362   return jresult;
4363 }
4364
4365
4366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4367   void * jresult ;
4368   Dali::Vector2 *result = 0 ;
4369
4370   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4371   jresult = (void *)result;
4372   return jresult;
4373 }
4374
4375
4376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4377   void * jresult ;
4378   Dali::Vector2 *result = 0 ;
4379
4380   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4381   jresult = (void *)result;
4382   return jresult;
4383 }
4384
4385
4386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4387   void * jresult ;
4388   Dali::Vector2 *result = 0 ;
4389
4390   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4391   jresult = (void *)result;
4392   return jresult;
4393 }
4394
4395
4396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4397   void * jresult ;
4398   Dali::Vector2 *result = 0 ;
4399
4400   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4401   jresult = (void *)result;
4402   return jresult;
4403 }
4404
4405
4406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4407   void * jresult ;
4408   Dali::Vector2 *result = 0 ;
4409
4410   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4411   jresult = (void *)result;
4412   return jresult;
4413 }
4414
4415
4416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4417   void * jresult ;
4418   Dali::Vector2 *result = 0 ;
4419
4420   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4421   jresult = (void *)result;
4422   return jresult;
4423 }
4424
4425
4426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4427   void * jresult ;
4428   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4429   float *arg2 = (float *) 0 ;
4430   Dali::Vector2 *result = 0 ;
4431
4432   arg1 = (Dali::Vector2 *)jarg1;
4433   arg2 = jarg2;
4434   {
4435     try {
4436       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4437     } catch (std::out_of_range& e) {
4438       {
4439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4440       };
4441     } catch (std::exception& e) {
4442       {
4443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4444       };
4445     } catch (Dali::DaliException e) {
4446       {
4447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4448       };
4449     } catch (...) {
4450       {
4451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4452       };
4453     }
4454   }
4455
4456   jresult = (void *)result;
4457
4458
4459   return jresult;
4460 }
4461
4462
4463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4464   void * jresult ;
4465   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4466   Dali::Vector3 *arg2 = 0 ;
4467   Dali::Vector2 *result = 0 ;
4468
4469   arg1 = (Dali::Vector2 *)jarg1;
4470   arg2 = (Dali::Vector3 *)jarg2;
4471   if (!arg2) {
4472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4473     return 0;
4474   }
4475   {
4476     try {
4477       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4478     } catch (std::out_of_range& e) {
4479       {
4480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4481       };
4482     } catch (std::exception& e) {
4483       {
4484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4485       };
4486     } catch (Dali::DaliException e) {
4487       {
4488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4489       };
4490     } catch (...) {
4491       {
4492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4493       };
4494     }
4495   }
4496
4497   jresult = (void *)result;
4498   return jresult;
4499 }
4500
4501
4502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4503   void * jresult ;
4504   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4505   Dali::Vector4 *arg2 = 0 ;
4506   Dali::Vector2 *result = 0 ;
4507
4508   arg1 = (Dali::Vector2 *)jarg1;
4509   arg2 = (Dali::Vector4 *)jarg2;
4510   if (!arg2) {
4511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4512     return 0;
4513   }
4514   {
4515     try {
4516       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4517     } catch (std::out_of_range& e) {
4518       {
4519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4520       };
4521     } catch (std::exception& e) {
4522       {
4523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4524       };
4525     } catch (Dali::DaliException e) {
4526       {
4527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4528       };
4529     } catch (...) {
4530       {
4531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4532       };
4533     }
4534   }
4535
4536   jresult = (void *)result;
4537   return jresult;
4538 }
4539
4540
4541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4542   void * jresult ;
4543   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4544   Dali::Vector2 *arg2 = 0 ;
4545   Dali::Vector2 result;
4546
4547   arg1 = (Dali::Vector2 *)jarg1;
4548   arg2 = (Dali::Vector2 *)jarg2;
4549   if (!arg2) {
4550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4551     return 0;
4552   }
4553   {
4554     try {
4555       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4556     } catch (std::out_of_range& e) {
4557       {
4558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4559       };
4560     } catch (std::exception& e) {
4561       {
4562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4563       };
4564     } catch (Dali::DaliException e) {
4565       {
4566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4567       };
4568     } catch (...) {
4569       {
4570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4571       };
4572     }
4573   }
4574
4575   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4576   return jresult;
4577 }
4578
4579
4580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4581   void * jresult ;
4582   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4583   Dali::Vector2 *arg2 = 0 ;
4584   Dali::Vector2 *result = 0 ;
4585
4586   arg1 = (Dali::Vector2 *)jarg1;
4587   arg2 = (Dali::Vector2 *)jarg2;
4588   if (!arg2) {
4589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4590     return 0;
4591   }
4592   {
4593     try {
4594       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4595     } catch (std::out_of_range& e) {
4596       {
4597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4598       };
4599     } catch (std::exception& e) {
4600       {
4601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4602       };
4603     } catch (Dali::DaliException e) {
4604       {
4605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4606       };
4607     } catch (...) {
4608       {
4609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4610       };
4611     }
4612   }
4613
4614   jresult = (void *)result;
4615   return jresult;
4616 }
4617
4618
4619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4620   void * jresult ;
4621   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4622   Dali::Vector2 *arg2 = 0 ;
4623   Dali::Vector2 result;
4624
4625   arg1 = (Dali::Vector2 *)jarg1;
4626   arg2 = (Dali::Vector2 *)jarg2;
4627   if (!arg2) {
4628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4629     return 0;
4630   }
4631   {
4632     try {
4633       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4634     } catch (std::out_of_range& e) {
4635       {
4636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4637       };
4638     } catch (std::exception& e) {
4639       {
4640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4641       };
4642     } catch (Dali::DaliException e) {
4643       {
4644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4645       };
4646     } catch (...) {
4647       {
4648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4649       };
4650     }
4651   }
4652
4653   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4654   return jresult;
4655 }
4656
4657
4658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4659   void * jresult ;
4660   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4661   Dali::Vector2 *arg2 = 0 ;
4662   Dali::Vector2 *result = 0 ;
4663
4664   arg1 = (Dali::Vector2 *)jarg1;
4665   arg2 = (Dali::Vector2 *)jarg2;
4666   if (!arg2) {
4667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4668     return 0;
4669   }
4670   {
4671     try {
4672       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4673     } catch (std::out_of_range& e) {
4674       {
4675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4676       };
4677     } catch (std::exception& e) {
4678       {
4679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4680       };
4681     } catch (Dali::DaliException e) {
4682       {
4683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4684       };
4685     } catch (...) {
4686       {
4687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4688       };
4689     }
4690   }
4691
4692   jresult = (void *)result;
4693   return jresult;
4694 }
4695
4696
4697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4698   void * jresult ;
4699   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4700   Dali::Vector2 *arg2 = 0 ;
4701   Dali::Vector2 result;
4702
4703   arg1 = (Dali::Vector2 *)jarg1;
4704   arg2 = (Dali::Vector2 *)jarg2;
4705   if (!arg2) {
4706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4707     return 0;
4708   }
4709   {
4710     try {
4711       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4712     } catch (std::out_of_range& e) {
4713       {
4714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4715       };
4716     } catch (std::exception& e) {
4717       {
4718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4719       };
4720     } catch (Dali::DaliException e) {
4721       {
4722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4723       };
4724     } catch (...) {
4725       {
4726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4727       };
4728     }
4729   }
4730
4731   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4732   return jresult;
4733 }
4734
4735
4736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4737   void * jresult ;
4738   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4739   float arg2 ;
4740   Dali::Vector2 result;
4741
4742   arg1 = (Dali::Vector2 *)jarg1;
4743   arg2 = (float)jarg2;
4744   {
4745     try {
4746       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4747     } catch (std::out_of_range& e) {
4748       {
4749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4750       };
4751     } catch (std::exception& e) {
4752       {
4753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4754       };
4755     } catch (Dali::DaliException e) {
4756       {
4757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4758       };
4759     } catch (...) {
4760       {
4761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4762       };
4763     }
4764   }
4765
4766   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4767   return jresult;
4768 }
4769
4770
4771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4772   void * jresult ;
4773   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4774   Dali::Vector2 *arg2 = 0 ;
4775   Dali::Vector2 *result = 0 ;
4776
4777   arg1 = (Dali::Vector2 *)jarg1;
4778   arg2 = (Dali::Vector2 *)jarg2;
4779   if (!arg2) {
4780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4781     return 0;
4782   }
4783   {
4784     try {
4785       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4786     } catch (std::out_of_range& e) {
4787       {
4788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4789       };
4790     } catch (std::exception& e) {
4791       {
4792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4793       };
4794     } catch (Dali::DaliException e) {
4795       {
4796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4797       };
4798     } catch (...) {
4799       {
4800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4801       };
4802     }
4803   }
4804
4805   jresult = (void *)result;
4806   return jresult;
4807 }
4808
4809
4810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4811   void * jresult ;
4812   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4813   float arg2 ;
4814   Dali::Vector2 *result = 0 ;
4815
4816   arg1 = (Dali::Vector2 *)jarg1;
4817   arg2 = (float)jarg2;
4818   {
4819     try {
4820       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4821     } catch (std::out_of_range& e) {
4822       {
4823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4824       };
4825     } catch (std::exception& e) {
4826       {
4827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4828       };
4829     } catch (Dali::DaliException e) {
4830       {
4831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4832       };
4833     } catch (...) {
4834       {
4835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4836       };
4837     }
4838   }
4839
4840   jresult = (void *)result;
4841   return jresult;
4842 }
4843
4844
4845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4846   void * jresult ;
4847   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4848   Dali::Vector2 *arg2 = 0 ;
4849   Dali::Vector2 result;
4850
4851   arg1 = (Dali::Vector2 *)jarg1;
4852   arg2 = (Dali::Vector2 *)jarg2;
4853   if (!arg2) {
4854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4855     return 0;
4856   }
4857   {
4858     try {
4859       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4860     } catch (std::out_of_range& e) {
4861       {
4862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4863       };
4864     } catch (std::exception& e) {
4865       {
4866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4867       };
4868     } catch (Dali::DaliException e) {
4869       {
4870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4871       };
4872     } catch (...) {
4873       {
4874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4875       };
4876     }
4877   }
4878
4879   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4880   return jresult;
4881 }
4882
4883
4884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4885   void * jresult ;
4886   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4887   float arg2 ;
4888   Dali::Vector2 result;
4889
4890   arg1 = (Dali::Vector2 *)jarg1;
4891   arg2 = (float)jarg2;
4892   {
4893     try {
4894       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4895     } catch (std::out_of_range& e) {
4896       {
4897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4898       };
4899     } catch (std::exception& e) {
4900       {
4901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4902       };
4903     } catch (Dali::DaliException e) {
4904       {
4905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4906       };
4907     } catch (...) {
4908       {
4909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4910       };
4911     }
4912   }
4913
4914   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4915   return jresult;
4916 }
4917
4918
4919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4920   void * jresult ;
4921   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4922   Dali::Vector2 *arg2 = 0 ;
4923   Dali::Vector2 *result = 0 ;
4924
4925   arg1 = (Dali::Vector2 *)jarg1;
4926   arg2 = (Dali::Vector2 *)jarg2;
4927   if (!arg2) {
4928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4929     return 0;
4930   }
4931   {
4932     try {
4933       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4934     } catch (std::out_of_range& e) {
4935       {
4936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4937       };
4938     } catch (std::exception& e) {
4939       {
4940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4941       };
4942     } catch (Dali::DaliException e) {
4943       {
4944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4945       };
4946     } catch (...) {
4947       {
4948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4949       };
4950     }
4951   }
4952
4953   jresult = (void *)result;
4954   return jresult;
4955 }
4956
4957
4958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4959   void * jresult ;
4960   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4961   float arg2 ;
4962   Dali::Vector2 *result = 0 ;
4963
4964   arg1 = (Dali::Vector2 *)jarg1;
4965   arg2 = (float)jarg2;
4966   {
4967     try {
4968       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4969     } catch (std::out_of_range& e) {
4970       {
4971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4972       };
4973     } catch (std::exception& e) {
4974       {
4975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4976       };
4977     } catch (Dali::DaliException e) {
4978       {
4979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4980       };
4981     } catch (...) {
4982       {
4983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4984       };
4985     }
4986   }
4987
4988   jresult = (void *)result;
4989   return jresult;
4990 }
4991
4992
4993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4994   void * jresult ;
4995   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4996   Dali::Vector2 result;
4997
4998   arg1 = (Dali::Vector2 *)jarg1;
4999   {
5000     try {
5001       result = ((Dali::Vector2 const *)arg1)->operator -();
5002     } catch (std::out_of_range& e) {
5003       {
5004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5005       };
5006     } catch (std::exception& e) {
5007       {
5008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5009       };
5010     } catch (Dali::DaliException e) {
5011       {
5012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5013       };
5014     } catch (...) {
5015       {
5016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5017       };
5018     }
5019   }
5020
5021   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5022   return jresult;
5023 }
5024
5025
5026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5027   unsigned int jresult ;
5028   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5029   Dali::Vector2 *arg2 = 0 ;
5030   bool result;
5031
5032   arg1 = (Dali::Vector2 *)jarg1;
5033   arg2 = (Dali::Vector2 *)jarg2;
5034   if (!arg2) {
5035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5036     return 0;
5037   }
5038   {
5039     try {
5040       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5041     } catch (std::out_of_range& e) {
5042       {
5043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5044       };
5045     } catch (std::exception& e) {
5046       {
5047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5048       };
5049     } catch (Dali::DaliException e) {
5050       {
5051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5052       };
5053     } catch (...) {
5054       {
5055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5056       };
5057     }
5058   }
5059
5060   jresult = result;
5061   return jresult;
5062 }
5063
5064
5065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5066   unsigned int jresult ;
5067   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5068   Dali::Vector2 *arg2 = 0 ;
5069   bool result;
5070
5071   arg1 = (Dali::Vector2 *)jarg1;
5072   arg2 = (Dali::Vector2 *)jarg2;
5073   if (!arg2) {
5074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5075     return 0;
5076   }
5077   {
5078     try {
5079       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5080     } catch (std::out_of_range& e) {
5081       {
5082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5083       };
5084     } catch (std::exception& e) {
5085       {
5086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5087       };
5088     } catch (Dali::DaliException e) {
5089       {
5090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5091       };
5092     } catch (...) {
5093       {
5094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5095       };
5096     }
5097   }
5098
5099   jresult = result;
5100   return jresult;
5101 }
5102
5103
5104 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5105   float jresult ;
5106   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5107   unsigned int arg2 ;
5108   float *result = 0 ;
5109
5110   arg1 = (Dali::Vector2 *)jarg1;
5111   arg2 = (unsigned int)jarg2;
5112   {
5113     try {
5114       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5115     } catch (std::out_of_range& e) {
5116       {
5117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5118       };
5119     } catch (std::exception& e) {
5120       {
5121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5122       };
5123     } catch (Dali::DaliException e) {
5124       {
5125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5126       };
5127     } catch (...) {
5128       {
5129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5130       };
5131     }
5132   }
5133
5134   jresult = *result;
5135   return jresult;
5136 }
5137
5138
5139 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5140   float jresult ;
5141   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5142   float result;
5143
5144   arg1 = (Dali::Vector2 *)jarg1;
5145   {
5146     try {
5147       result = (float)((Dali::Vector2 const *)arg1)->Length();
5148     } catch (std::out_of_range& e) {
5149       {
5150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5151       };
5152     } catch (std::exception& e) {
5153       {
5154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5155       };
5156     } catch (Dali::DaliException e) {
5157       {
5158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5159       };
5160     } catch (...) {
5161       {
5162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5163       };
5164     }
5165   }
5166
5167   jresult = result;
5168   return jresult;
5169 }
5170
5171
5172 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5173   float jresult ;
5174   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5175   float result;
5176
5177   arg1 = (Dali::Vector2 *)jarg1;
5178   {
5179     try {
5180       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5181     } catch (std::out_of_range& e) {
5182       {
5183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5184       };
5185     } catch (std::exception& e) {
5186       {
5187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5188       };
5189     } catch (Dali::DaliException e) {
5190       {
5191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5192       };
5193     } catch (...) {
5194       {
5195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5196       };
5197     }
5198   }
5199
5200   jresult = result;
5201   return jresult;
5202 }
5203
5204
5205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5206   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5207
5208   arg1 = (Dali::Vector2 *)jarg1;
5209   {
5210     try {
5211       (arg1)->Normalize();
5212     } catch (std::out_of_range& e) {
5213       {
5214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5215       };
5216     } catch (std::exception& e) {
5217       {
5218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5219       };
5220     } catch (Dali::DaliException e) {
5221       {
5222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5223       };
5224     } catch (...) {
5225       {
5226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5227       };
5228     }
5229   }
5230
5231 }
5232
5233
5234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5235   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5236   Dali::Vector2 *arg2 = 0 ;
5237   Dali::Vector2 *arg3 = 0 ;
5238
5239   arg1 = (Dali::Vector2 *)jarg1;
5240   arg2 = (Dali::Vector2 *)jarg2;
5241   if (!arg2) {
5242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5243     return ;
5244   }
5245   arg3 = (Dali::Vector2 *)jarg3;
5246   if (!arg3) {
5247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5248     return ;
5249   }
5250   {
5251     try {
5252       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5253     } catch (std::out_of_range& e) {
5254       {
5255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5256       };
5257     } catch (std::exception& e) {
5258       {
5259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5260       };
5261     } catch (Dali::DaliException e) {
5262       {
5263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5264       };
5265     } catch (...) {
5266       {
5267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5268       };
5269     }
5270   }
5271
5272 }
5273
5274
5275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5276   void * jresult ;
5277   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5278   float *result = 0 ;
5279
5280   arg1 = (Dali::Vector2 *)jarg1;
5281   {
5282     try {
5283       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5284     } catch (std::out_of_range& e) {
5285       {
5286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5287       };
5288     } catch (std::exception& e) {
5289       {
5290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5291       };
5292     } catch (Dali::DaliException e) {
5293       {
5294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5295       };
5296     } catch (...) {
5297       {
5298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5299       };
5300     }
5301   }
5302
5303   jresult = (void *)result;
5304   return jresult;
5305 }
5306
5307
5308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5309   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5310   float arg2 ;
5311
5312   arg1 = (Dali::Vector2 *)jarg1;
5313   arg2 = (float)jarg2;
5314   if (arg1) (arg1)->x = arg2;
5315 }
5316
5317
5318 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5319   float jresult ;
5320   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5321   float result;
5322
5323   arg1 = (Dali::Vector2 *)jarg1;
5324   result = (float) ((arg1)->x);
5325   jresult = result;
5326   return jresult;
5327 }
5328
5329
5330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5331   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5332   float arg2 ;
5333
5334   arg1 = (Dali::Vector2 *)jarg1;
5335   arg2 = (float)jarg2;
5336   if (arg1) (arg1)->width = arg2;
5337 }
5338
5339
5340 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5341   float jresult ;
5342   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5343   float result;
5344
5345   arg1 = (Dali::Vector2 *)jarg1;
5346   result = (float) ((arg1)->width);
5347   jresult = result;
5348   return jresult;
5349 }
5350
5351
5352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5353   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5354   float arg2 ;
5355
5356   arg1 = (Dali::Vector2 *)jarg1;
5357   arg2 = (float)jarg2;
5358   if (arg1) (arg1)->y = arg2;
5359 }
5360
5361
5362 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5363   float jresult ;
5364   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5365   float result;
5366
5367   arg1 = (Dali::Vector2 *)jarg1;
5368   result = (float) ((arg1)->y);
5369   jresult = result;
5370   return jresult;
5371 }
5372
5373
5374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5375   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5376   float arg2 ;
5377
5378   arg1 = (Dali::Vector2 *)jarg1;
5379   arg2 = (float)jarg2;
5380   if (arg1) (arg1)->height = arg2;
5381 }
5382
5383
5384 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5385   float jresult ;
5386   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5387   float result;
5388
5389   arg1 = (Dali::Vector2 *)jarg1;
5390   result = (float) ((arg1)->height);
5391   jresult = result;
5392   return jresult;
5393 }
5394
5395
5396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5397   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5398
5399   arg1 = (Dali::Vector2 *)jarg1;
5400   {
5401     try {
5402       delete arg1;
5403     } catch (std::out_of_range& e) {
5404       {
5405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5406       };
5407     } catch (std::exception& e) {
5408       {
5409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5410       };
5411     } catch (Dali::DaliException e) {
5412       {
5413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5414       };
5415     } catch (...) {
5416       {
5417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5418       };
5419     }
5420   }
5421
5422 }
5423
5424
5425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5426   void * jresult ;
5427   Dali::Vector2 *arg1 = 0 ;
5428   Dali::Vector2 *arg2 = 0 ;
5429   Dali::Vector2 result;
5430
5431   arg1 = (Dali::Vector2 *)jarg1;
5432   if (!arg1) {
5433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5434     return 0;
5435   }
5436   arg2 = (Dali::Vector2 *)jarg2;
5437   if (!arg2) {
5438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5439     return 0;
5440   }
5441   {
5442     try {
5443       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5444     } catch (std::out_of_range& e) {
5445       {
5446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5447       };
5448     } catch (std::exception& e) {
5449       {
5450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5451       };
5452     } catch (Dali::DaliException e) {
5453       {
5454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5455       };
5456     } catch (...) {
5457       {
5458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5459       };
5460     }
5461   }
5462
5463   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5464   return jresult;
5465 }
5466
5467
5468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5469   void * jresult ;
5470   Dali::Vector2 *arg1 = 0 ;
5471   Dali::Vector2 *arg2 = 0 ;
5472   Dali::Vector2 result;
5473
5474   arg1 = (Dali::Vector2 *)jarg1;
5475   if (!arg1) {
5476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5477     return 0;
5478   }
5479   arg2 = (Dali::Vector2 *)jarg2;
5480   if (!arg2) {
5481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5482     return 0;
5483   }
5484   {
5485     try {
5486       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5487     } catch (std::out_of_range& e) {
5488       {
5489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5490       };
5491     } catch (std::exception& e) {
5492       {
5493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5494       };
5495     } catch (Dali::DaliException e) {
5496       {
5497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5498       };
5499     } catch (...) {
5500       {
5501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5502       };
5503     }
5504   }
5505
5506   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5507   return jresult;
5508 }
5509
5510
5511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5512   void * jresult ;
5513   Dali::Vector2 *arg1 = 0 ;
5514   float *arg2 = 0 ;
5515   float *arg3 = 0 ;
5516   float temp2 ;
5517   float temp3 ;
5518   Dali::Vector2 result;
5519
5520   arg1 = (Dali::Vector2 *)jarg1;
5521   if (!arg1) {
5522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5523     return 0;
5524   }
5525   temp2 = (float)jarg2;
5526   arg2 = &temp2;
5527   temp3 = (float)jarg3;
5528   arg3 = &temp3;
5529   {
5530     try {
5531       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5532     } catch (std::out_of_range& e) {
5533       {
5534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5535       };
5536     } catch (std::exception& e) {
5537       {
5538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5539       };
5540     } catch (Dali::DaliException e) {
5541       {
5542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5543       };
5544     } catch (...) {
5545       {
5546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5547       };
5548     }
5549   }
5550
5551   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5552   return jresult;
5553 }
5554
5555
5556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5557   void * jresult ;
5558   Dali::Vector3 *result = 0 ;
5559
5560   {
5561     try {
5562       result = (Dali::Vector3 *)new Dali::Vector3();
5563     } catch (std::out_of_range& e) {
5564       {
5565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5566       };
5567     } catch (std::exception& e) {
5568       {
5569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5570       };
5571     } catch (Dali::DaliException e) {
5572       {
5573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5574       };
5575     } catch (...) {
5576       {
5577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5578       };
5579     }
5580   }
5581
5582   jresult = (void *)result;
5583   return jresult;
5584 }
5585
5586
5587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5588   void * jresult ;
5589   float arg1 ;
5590   float arg2 ;
5591   float arg3 ;
5592   Dali::Vector3 *result = 0 ;
5593
5594   arg1 = (float)jarg1;
5595   arg2 = (float)jarg2;
5596   arg3 = (float)jarg3;
5597   {
5598     try {
5599       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5600     } catch (std::out_of_range& e) {
5601       {
5602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5603       };
5604     } catch (std::exception& e) {
5605       {
5606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5607       };
5608     } catch (Dali::DaliException e) {
5609       {
5610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5611       };
5612     } catch (...) {
5613       {
5614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5615       };
5616     }
5617   }
5618
5619   jresult = (void *)result;
5620   return jresult;
5621 }
5622
5623
5624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5625   void * jresult ;
5626   float *arg1 = (float *) 0 ;
5627   Dali::Vector3 *result = 0 ;
5628
5629   arg1 = jarg1;
5630   {
5631     try {
5632       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5633     } catch (std::out_of_range& e) {
5634       {
5635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5636       };
5637     } catch (std::exception& e) {
5638       {
5639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5640       };
5641     } catch (Dali::DaliException e) {
5642       {
5643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5644       };
5645     } catch (...) {
5646       {
5647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5648       };
5649     }
5650   }
5651
5652   jresult = (void *)result;
5653
5654
5655   return jresult;
5656 }
5657
5658
5659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5660   void * jresult ;
5661   Dali::Vector2 *arg1 = 0 ;
5662   Dali::Vector3 *result = 0 ;
5663
5664   arg1 = (Dali::Vector2 *)jarg1;
5665   if (!arg1) {
5666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5667     return 0;
5668   }
5669   {
5670     try {
5671       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5672     } catch (std::out_of_range& e) {
5673       {
5674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5675       };
5676     } catch (std::exception& e) {
5677       {
5678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5679       };
5680     } catch (Dali::DaliException e) {
5681       {
5682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5683       };
5684     } catch (...) {
5685       {
5686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5687       };
5688     }
5689   }
5690
5691   jresult = (void *)result;
5692   return jresult;
5693 }
5694
5695
5696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5697   void * jresult ;
5698   Dali::Vector4 *arg1 = 0 ;
5699   Dali::Vector3 *result = 0 ;
5700
5701   arg1 = (Dali::Vector4 *)jarg1;
5702   if (!arg1) {
5703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5704     return 0;
5705   }
5706   {
5707     try {
5708       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5709     } catch (std::out_of_range& e) {
5710       {
5711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5712       };
5713     } catch (std::exception& e) {
5714       {
5715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5716       };
5717     } catch (Dali::DaliException e) {
5718       {
5719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5720       };
5721     } catch (...) {
5722       {
5723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5724       };
5725     }
5726   }
5727
5728   jresult = (void *)result;
5729   return jresult;
5730 }
5731
5732
5733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5734   void * jresult ;
5735   Dali::Vector3 *result = 0 ;
5736
5737   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5738   jresult = (void *)result;
5739   return jresult;
5740 }
5741
5742
5743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5744   void * jresult ;
5745   Dali::Vector3 *result = 0 ;
5746
5747   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5748   jresult = (void *)result;
5749   return jresult;
5750 }
5751
5752
5753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5754   void * jresult ;
5755   Dali::Vector3 *result = 0 ;
5756
5757   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5758   jresult = (void *)result;
5759   return jresult;
5760 }
5761
5762
5763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5764   void * jresult ;
5765   Dali::Vector3 *result = 0 ;
5766
5767   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5768   jresult = (void *)result;
5769   return jresult;
5770 }
5771
5772
5773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5774   void * jresult ;
5775   Dali::Vector3 *result = 0 ;
5776
5777   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5778   jresult = (void *)result;
5779   return jresult;
5780 }
5781
5782
5783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5784   void * jresult ;
5785   Dali::Vector3 *result = 0 ;
5786
5787   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5788   jresult = (void *)result;
5789   return jresult;
5790 }
5791
5792
5793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5794   void * jresult ;
5795   Dali::Vector3 *result = 0 ;
5796
5797   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5798   jresult = (void *)result;
5799   return jresult;
5800 }
5801
5802
5803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5804   void * jresult ;
5805   Dali::Vector3 *result = 0 ;
5806
5807   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5808   jresult = (void *)result;
5809   return jresult;
5810 }
5811
5812
5813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5814   void * jresult ;
5815   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5816   float *arg2 = (float *) 0 ;
5817   Dali::Vector3 *result = 0 ;
5818
5819   arg1 = (Dali::Vector3 *)jarg1;
5820   arg2 = jarg2;
5821   {
5822     try {
5823       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5824     } catch (std::out_of_range& e) {
5825       {
5826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5827       };
5828     } catch (std::exception& e) {
5829       {
5830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5831       };
5832     } catch (Dali::DaliException e) {
5833       {
5834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5835       };
5836     } catch (...) {
5837       {
5838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5839       };
5840     }
5841   }
5842
5843   jresult = (void *)result;
5844
5845
5846   return jresult;
5847 }
5848
5849
5850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5851   void * jresult ;
5852   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5853   Dali::Vector2 *arg2 = 0 ;
5854   Dali::Vector3 *result = 0 ;
5855
5856   arg1 = (Dali::Vector3 *)jarg1;
5857   arg2 = (Dali::Vector2 *)jarg2;
5858   if (!arg2) {
5859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5860     return 0;
5861   }
5862   {
5863     try {
5864       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5865     } catch (std::out_of_range& e) {
5866       {
5867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5868       };
5869     } catch (std::exception& e) {
5870       {
5871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5872       };
5873     } catch (Dali::DaliException e) {
5874       {
5875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5876       };
5877     } catch (...) {
5878       {
5879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5880       };
5881     }
5882   }
5883
5884   jresult = (void *)result;
5885   return jresult;
5886 }
5887
5888
5889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5890   void * jresult ;
5891   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5892   Dali::Vector4 *arg2 = 0 ;
5893   Dali::Vector3 *result = 0 ;
5894
5895   arg1 = (Dali::Vector3 *)jarg1;
5896   arg2 = (Dali::Vector4 *)jarg2;
5897   if (!arg2) {
5898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5899     return 0;
5900   }
5901   {
5902     try {
5903       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5904     } catch (std::out_of_range& e) {
5905       {
5906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5907       };
5908     } catch (std::exception& e) {
5909       {
5910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5911       };
5912     } catch (Dali::DaliException e) {
5913       {
5914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5915       };
5916     } catch (...) {
5917       {
5918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5919       };
5920     }
5921   }
5922
5923   jresult = (void *)result;
5924   return jresult;
5925 }
5926
5927
5928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5929   void * jresult ;
5930   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5931   Dali::Vector3 *arg2 = 0 ;
5932   Dali::Vector3 result;
5933
5934   arg1 = (Dali::Vector3 *)jarg1;
5935   arg2 = (Dali::Vector3 *)jarg2;
5936   if (!arg2) {
5937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5938     return 0;
5939   }
5940   {
5941     try {
5942       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5943     } catch (std::out_of_range& e) {
5944       {
5945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5946       };
5947     } catch (std::exception& e) {
5948       {
5949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5950       };
5951     } catch (Dali::DaliException e) {
5952       {
5953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5954       };
5955     } catch (...) {
5956       {
5957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5958       };
5959     }
5960   }
5961
5962   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5963   return jresult;
5964 }
5965
5966
5967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5968   void * jresult ;
5969   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5970   Dali::Vector3 *arg2 = 0 ;
5971   Dali::Vector3 *result = 0 ;
5972
5973   arg1 = (Dali::Vector3 *)jarg1;
5974   arg2 = (Dali::Vector3 *)jarg2;
5975   if (!arg2) {
5976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5977     return 0;
5978   }
5979   {
5980     try {
5981       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5982     } catch (std::out_of_range& e) {
5983       {
5984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5985       };
5986     } catch (std::exception& e) {
5987       {
5988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5989       };
5990     } catch (Dali::DaliException e) {
5991       {
5992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5993       };
5994     } catch (...) {
5995       {
5996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5997       };
5998     }
5999   }
6000
6001   jresult = (void *)result;
6002   return jresult;
6003 }
6004
6005
6006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6007   void * jresult ;
6008   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6009   Dali::Vector3 *arg2 = 0 ;
6010   Dali::Vector3 result;
6011
6012   arg1 = (Dali::Vector3 *)jarg1;
6013   arg2 = (Dali::Vector3 *)jarg2;
6014   if (!arg2) {
6015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6016     return 0;
6017   }
6018   {
6019     try {
6020       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6021     } catch (std::out_of_range& e) {
6022       {
6023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6024       };
6025     } catch (std::exception& e) {
6026       {
6027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6028       };
6029     } catch (Dali::DaliException e) {
6030       {
6031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6032       };
6033     } catch (...) {
6034       {
6035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6036       };
6037     }
6038   }
6039
6040   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6041   return jresult;
6042 }
6043
6044
6045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6046   void * jresult ;
6047   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6048   Dali::Vector3 *arg2 = 0 ;
6049   Dali::Vector3 *result = 0 ;
6050
6051   arg1 = (Dali::Vector3 *)jarg1;
6052   arg2 = (Dali::Vector3 *)jarg2;
6053   if (!arg2) {
6054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6055     return 0;
6056   }
6057   {
6058     try {
6059       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6060     } catch (std::out_of_range& e) {
6061       {
6062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6063       };
6064     } catch (std::exception& e) {
6065       {
6066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6067       };
6068     } catch (Dali::DaliException e) {
6069       {
6070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6071       };
6072     } catch (...) {
6073       {
6074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6075       };
6076     }
6077   }
6078
6079   jresult = (void *)result;
6080   return jresult;
6081 }
6082
6083
6084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6085   void * jresult ;
6086   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6087   Dali::Vector3 *arg2 = 0 ;
6088   Dali::Vector3 result;
6089
6090   arg1 = (Dali::Vector3 *)jarg1;
6091   arg2 = (Dali::Vector3 *)jarg2;
6092   if (!arg2) {
6093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6094     return 0;
6095   }
6096   {
6097     try {
6098       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6099     } catch (std::out_of_range& e) {
6100       {
6101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6102       };
6103     } catch (std::exception& e) {
6104       {
6105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6106       };
6107     } catch (Dali::DaliException e) {
6108       {
6109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6110       };
6111     } catch (...) {
6112       {
6113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6114       };
6115     }
6116   }
6117
6118   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6119   return jresult;
6120 }
6121
6122
6123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6124   void * jresult ;
6125   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6126   float arg2 ;
6127   Dali::Vector3 result;
6128
6129   arg1 = (Dali::Vector3 *)jarg1;
6130   arg2 = (float)jarg2;
6131   {
6132     try {
6133       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6134     } catch (std::out_of_range& e) {
6135       {
6136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6137       };
6138     } catch (std::exception& e) {
6139       {
6140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6141       };
6142     } catch (Dali::DaliException e) {
6143       {
6144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6145       };
6146     } catch (...) {
6147       {
6148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6149       };
6150     }
6151   }
6152
6153   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6154   return jresult;
6155 }
6156
6157
6158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6159   void * jresult ;
6160   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6161   Dali::Vector3 *arg2 = 0 ;
6162   Dali::Vector3 *result = 0 ;
6163
6164   arg1 = (Dali::Vector3 *)jarg1;
6165   arg2 = (Dali::Vector3 *)jarg2;
6166   if (!arg2) {
6167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6168     return 0;
6169   }
6170   {
6171     try {
6172       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6173     } catch (std::out_of_range& e) {
6174       {
6175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6176       };
6177     } catch (std::exception& e) {
6178       {
6179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6180       };
6181     } catch (Dali::DaliException e) {
6182       {
6183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6184       };
6185     } catch (...) {
6186       {
6187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6188       };
6189     }
6190   }
6191
6192   jresult = (void *)result;
6193   return jresult;
6194 }
6195
6196
6197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6198   void * jresult ;
6199   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6200   float arg2 ;
6201   Dali::Vector3 *result = 0 ;
6202
6203   arg1 = (Dali::Vector3 *)jarg1;
6204   arg2 = (float)jarg2;
6205   {
6206     try {
6207       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6208     } catch (std::out_of_range& e) {
6209       {
6210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6211       };
6212     } catch (std::exception& e) {
6213       {
6214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6215       };
6216     } catch (Dali::DaliException e) {
6217       {
6218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6219       };
6220     } catch (...) {
6221       {
6222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6223       };
6224     }
6225   }
6226
6227   jresult = (void *)result;
6228   return jresult;
6229 }
6230
6231
6232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6233   void * jresult ;
6234   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6235   Dali::Quaternion *arg2 = 0 ;
6236   Dali::Vector3 *result = 0 ;
6237
6238   arg1 = (Dali::Vector3 *)jarg1;
6239   arg2 = (Dali::Quaternion *)jarg2;
6240   if (!arg2) {
6241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6242     return 0;
6243   }
6244   {
6245     try {
6246       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6247     } catch (std::out_of_range& e) {
6248       {
6249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6250       };
6251     } catch (std::exception& e) {
6252       {
6253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6254       };
6255     } catch (Dali::DaliException e) {
6256       {
6257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6258       };
6259     } catch (...) {
6260       {
6261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6262       };
6263     }
6264   }
6265
6266   jresult = (void *)result;
6267   return jresult;
6268 }
6269
6270
6271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6272   void * jresult ;
6273   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6274   Dali::Vector3 *arg2 = 0 ;
6275   Dali::Vector3 result;
6276
6277   arg1 = (Dali::Vector3 *)jarg1;
6278   arg2 = (Dali::Vector3 *)jarg2;
6279   if (!arg2) {
6280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6281     return 0;
6282   }
6283   {
6284     try {
6285       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6286     } catch (std::out_of_range& e) {
6287       {
6288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6289       };
6290     } catch (std::exception& e) {
6291       {
6292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6293       };
6294     } catch (Dali::DaliException e) {
6295       {
6296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6297       };
6298     } catch (...) {
6299       {
6300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6301       };
6302     }
6303   }
6304
6305   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6306   return jresult;
6307 }
6308
6309
6310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6311   void * jresult ;
6312   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6313   float arg2 ;
6314   Dali::Vector3 result;
6315
6316   arg1 = (Dali::Vector3 *)jarg1;
6317   arg2 = (float)jarg2;
6318   {
6319     try {
6320       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6321     } catch (std::out_of_range& e) {
6322       {
6323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6324       };
6325     } catch (std::exception& e) {
6326       {
6327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6328       };
6329     } catch (Dali::DaliException e) {
6330       {
6331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6332       };
6333     } catch (...) {
6334       {
6335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6336       };
6337     }
6338   }
6339
6340   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6341   return jresult;
6342 }
6343
6344
6345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6346   void * jresult ;
6347   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6348   Dali::Vector3 *arg2 = 0 ;
6349   Dali::Vector3 *result = 0 ;
6350
6351   arg1 = (Dali::Vector3 *)jarg1;
6352   arg2 = (Dali::Vector3 *)jarg2;
6353   if (!arg2) {
6354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6355     return 0;
6356   }
6357   {
6358     try {
6359       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6360     } catch (std::out_of_range& e) {
6361       {
6362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6363       };
6364     } catch (std::exception& e) {
6365       {
6366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6367       };
6368     } catch (Dali::DaliException e) {
6369       {
6370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6371       };
6372     } catch (...) {
6373       {
6374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6375       };
6376     }
6377   }
6378
6379   jresult = (void *)result;
6380   return jresult;
6381 }
6382
6383
6384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6385   void * jresult ;
6386   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6387   float arg2 ;
6388   Dali::Vector3 *result = 0 ;
6389
6390   arg1 = (Dali::Vector3 *)jarg1;
6391   arg2 = (float)jarg2;
6392   {
6393     try {
6394       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6395     } catch (std::out_of_range& e) {
6396       {
6397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6398       };
6399     } catch (std::exception& e) {
6400       {
6401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6402       };
6403     } catch (Dali::DaliException e) {
6404       {
6405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6406       };
6407     } catch (...) {
6408       {
6409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6410       };
6411     }
6412   }
6413
6414   jresult = (void *)result;
6415   return jresult;
6416 }
6417
6418
6419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6420   void * jresult ;
6421   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6422   Dali::Vector3 result;
6423
6424   arg1 = (Dali::Vector3 *)jarg1;
6425   {
6426     try {
6427       result = ((Dali::Vector3 const *)arg1)->operator -();
6428     } catch (std::out_of_range& e) {
6429       {
6430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6431       };
6432     } catch (std::exception& e) {
6433       {
6434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6435       };
6436     } catch (Dali::DaliException e) {
6437       {
6438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6439       };
6440     } catch (...) {
6441       {
6442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6443       };
6444     }
6445   }
6446
6447   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6448   return jresult;
6449 }
6450
6451
6452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6453   unsigned int jresult ;
6454   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6455   Dali::Vector3 *arg2 = 0 ;
6456   bool result;
6457
6458   arg1 = (Dali::Vector3 *)jarg1;
6459   arg2 = (Dali::Vector3 *)jarg2;
6460   if (!arg2) {
6461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6462     return 0;
6463   }
6464   {
6465     try {
6466       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6467     } catch (std::out_of_range& e) {
6468       {
6469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6470       };
6471     } catch (std::exception& e) {
6472       {
6473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6474       };
6475     } catch (Dali::DaliException e) {
6476       {
6477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6478       };
6479     } catch (...) {
6480       {
6481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6482       };
6483     }
6484   }
6485
6486   jresult = result;
6487   return jresult;
6488 }
6489
6490
6491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6492   unsigned int jresult ;
6493   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6494   Dali::Vector3 *arg2 = 0 ;
6495   bool result;
6496
6497   arg1 = (Dali::Vector3 *)jarg1;
6498   arg2 = (Dali::Vector3 *)jarg2;
6499   if (!arg2) {
6500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6501     return 0;
6502   }
6503   {
6504     try {
6505       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6506     } catch (std::out_of_range& e) {
6507       {
6508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6509       };
6510     } catch (std::exception& e) {
6511       {
6512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6513       };
6514     } catch (Dali::DaliException e) {
6515       {
6516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6517       };
6518     } catch (...) {
6519       {
6520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6521       };
6522     }
6523   }
6524
6525   jresult = result;
6526   return jresult;
6527 }
6528
6529
6530 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6531   float jresult ;
6532   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6533   unsigned int arg2 ;
6534   float *result = 0 ;
6535
6536   arg1 = (Dali::Vector3 *)jarg1;
6537   arg2 = (unsigned int)jarg2;
6538   {
6539     try {
6540       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6541     } catch (std::out_of_range& e) {
6542       {
6543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6544       };
6545     } catch (std::exception& e) {
6546       {
6547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6548       };
6549     } catch (Dali::DaliException e) {
6550       {
6551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6552       };
6553     } catch (...) {
6554       {
6555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6556       };
6557     }
6558   }
6559
6560   jresult = *result;
6561   return jresult;
6562 }
6563
6564
6565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6566   float jresult ;
6567   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6568   Dali::Vector3 *arg2 = 0 ;
6569   float result;
6570
6571   arg1 = (Dali::Vector3 *)jarg1;
6572   arg2 = (Dali::Vector3 *)jarg2;
6573   if (!arg2) {
6574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6575     return 0;
6576   }
6577   {
6578     try {
6579       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6580     } catch (std::out_of_range& e) {
6581       {
6582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6583       };
6584     } catch (std::exception& e) {
6585       {
6586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6587       };
6588     } catch (Dali::DaliException e) {
6589       {
6590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6591       };
6592     } catch (...) {
6593       {
6594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6595       };
6596     }
6597   }
6598
6599   jresult = result;
6600   return jresult;
6601 }
6602
6603
6604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6605   void * jresult ;
6606   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6607   Dali::Vector3 *arg2 = 0 ;
6608   Dali::Vector3 result;
6609
6610   arg1 = (Dali::Vector3 *)jarg1;
6611   arg2 = (Dali::Vector3 *)jarg2;
6612   if (!arg2) {
6613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6614     return 0;
6615   }
6616   {
6617     try {
6618       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6619     } catch (std::out_of_range& e) {
6620       {
6621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6622       };
6623     } catch (std::exception& e) {
6624       {
6625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6626       };
6627     } catch (Dali::DaliException e) {
6628       {
6629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6630       };
6631     } catch (...) {
6632       {
6633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6634       };
6635     }
6636   }
6637
6638   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6639   return jresult;
6640 }
6641
6642
6643 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6644   float jresult ;
6645   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6646   float result;
6647
6648   arg1 = (Dali::Vector3 *)jarg1;
6649   {
6650     try {
6651       result = (float)((Dali::Vector3 const *)arg1)->Length();
6652     } catch (std::out_of_range& e) {
6653       {
6654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6655       };
6656     } catch (std::exception& e) {
6657       {
6658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6659       };
6660     } catch (Dali::DaliException e) {
6661       {
6662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6663       };
6664     } catch (...) {
6665       {
6666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6667       };
6668     }
6669   }
6670
6671   jresult = result;
6672   return jresult;
6673 }
6674
6675
6676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6677   float jresult ;
6678   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6679   float result;
6680
6681   arg1 = (Dali::Vector3 *)jarg1;
6682   {
6683     try {
6684       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6685     } catch (std::out_of_range& e) {
6686       {
6687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6688       };
6689     } catch (std::exception& e) {
6690       {
6691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6692       };
6693     } catch (Dali::DaliException e) {
6694       {
6695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6696       };
6697     } catch (...) {
6698       {
6699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6700       };
6701     }
6702   }
6703
6704   jresult = result;
6705   return jresult;
6706 }
6707
6708
6709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6710   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6711
6712   arg1 = (Dali::Vector3 *)jarg1;
6713   {
6714     try {
6715       (arg1)->Normalize();
6716     } catch (std::out_of_range& e) {
6717       {
6718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6719       };
6720     } catch (std::exception& e) {
6721       {
6722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6723       };
6724     } catch (Dali::DaliException e) {
6725       {
6726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6727       };
6728     } catch (...) {
6729       {
6730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6731       };
6732     }
6733   }
6734
6735 }
6736
6737
6738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6739   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6740   Dali::Vector3 *arg2 = 0 ;
6741   Dali::Vector3 *arg3 = 0 ;
6742
6743   arg1 = (Dali::Vector3 *)jarg1;
6744   arg2 = (Dali::Vector3 *)jarg2;
6745   if (!arg2) {
6746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6747     return ;
6748   }
6749   arg3 = (Dali::Vector3 *)jarg3;
6750   if (!arg3) {
6751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6752     return ;
6753   }
6754   {
6755     try {
6756       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6757     } catch (std::out_of_range& e) {
6758       {
6759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6760       };
6761     } catch (std::exception& e) {
6762       {
6763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6764       };
6765     } catch (Dali::DaliException e) {
6766       {
6767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6768       };
6769     } catch (...) {
6770       {
6771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6772       };
6773     }
6774   }
6775
6776 }
6777
6778
6779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6780   void * jresult ;
6781   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6782   float *result = 0 ;
6783
6784   arg1 = (Dali::Vector3 *)jarg1;
6785   {
6786     try {
6787       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6788     } catch (std::out_of_range& e) {
6789       {
6790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6791       };
6792     } catch (std::exception& e) {
6793       {
6794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6795       };
6796     } catch (Dali::DaliException e) {
6797       {
6798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6799       };
6800     } catch (...) {
6801       {
6802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6803       };
6804     }
6805   }
6806
6807   jresult = (void *)result;
6808   return jresult;
6809 }
6810
6811
6812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6813   void * jresult ;
6814   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6815   Dali::Vector2 *result = 0 ;
6816
6817   arg1 = (Dali::Vector3 *)jarg1;
6818   {
6819     try {
6820       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6821     } catch (std::out_of_range& e) {
6822       {
6823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6824       };
6825     } catch (std::exception& e) {
6826       {
6827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6828       };
6829     } catch (Dali::DaliException e) {
6830       {
6831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6832       };
6833     } catch (...) {
6834       {
6835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6836       };
6837     }
6838   }
6839
6840   jresult = (void *)result;
6841   return jresult;
6842 }
6843
6844
6845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6846   void * jresult ;
6847   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6848   Dali::Vector2 *result = 0 ;
6849
6850   arg1 = (Dali::Vector3 *)jarg1;
6851   {
6852     try {
6853       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6854     } catch (std::out_of_range& e) {
6855       {
6856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6857       };
6858     } catch (std::exception& e) {
6859       {
6860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6861       };
6862     } catch (Dali::DaliException e) {
6863       {
6864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6865       };
6866     } catch (...) {
6867       {
6868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6869       };
6870     }
6871   }
6872
6873   jresult = (void *)result;
6874   return jresult;
6875 }
6876
6877
6878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6879   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6880   float arg2 ;
6881
6882   arg1 = (Dali::Vector3 *)jarg1;
6883   arg2 = (float)jarg2;
6884   if (arg1) (arg1)->x = arg2;
6885 }
6886
6887
6888 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6889   float jresult ;
6890   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6891   float result;
6892
6893   arg1 = (Dali::Vector3 *)jarg1;
6894   result = (float) ((arg1)->x);
6895   jresult = result;
6896   return jresult;
6897 }
6898
6899
6900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6901   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6902   float arg2 ;
6903
6904   arg1 = (Dali::Vector3 *)jarg1;
6905   arg2 = (float)jarg2;
6906   if (arg1) (arg1)->width = arg2;
6907 }
6908
6909
6910 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6911   float jresult ;
6912   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6913   float result;
6914
6915   arg1 = (Dali::Vector3 *)jarg1;
6916   result = (float) ((arg1)->width);
6917   jresult = result;
6918   return jresult;
6919 }
6920
6921
6922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6923   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6924   float arg2 ;
6925
6926   arg1 = (Dali::Vector3 *)jarg1;
6927   arg2 = (float)jarg2;
6928   if (arg1) (arg1)->r = arg2;
6929 }
6930
6931
6932 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6933   float jresult ;
6934   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6935   float result;
6936
6937   arg1 = (Dali::Vector3 *)jarg1;
6938   result = (float) ((arg1)->r);
6939   jresult = result;
6940   return jresult;
6941 }
6942
6943
6944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6945   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6946   float arg2 ;
6947
6948   arg1 = (Dali::Vector3 *)jarg1;
6949   arg2 = (float)jarg2;
6950   if (arg1) (arg1)->y = arg2;
6951 }
6952
6953
6954 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6955   float jresult ;
6956   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6957   float result;
6958
6959   arg1 = (Dali::Vector3 *)jarg1;
6960   result = (float) ((arg1)->y);
6961   jresult = result;
6962   return jresult;
6963 }
6964
6965
6966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6967   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6968   float arg2 ;
6969
6970   arg1 = (Dali::Vector3 *)jarg1;
6971   arg2 = (float)jarg2;
6972   if (arg1) (arg1)->height = arg2;
6973 }
6974
6975
6976 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6977   float jresult ;
6978   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6979   float result;
6980
6981   arg1 = (Dali::Vector3 *)jarg1;
6982   result = (float) ((arg1)->height);
6983   jresult = result;
6984   return jresult;
6985 }
6986
6987
6988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6989   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6990   float arg2 ;
6991
6992   arg1 = (Dali::Vector3 *)jarg1;
6993   arg2 = (float)jarg2;
6994   if (arg1) (arg1)->g = arg2;
6995 }
6996
6997
6998 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6999   float jresult ;
7000   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7001   float result;
7002
7003   arg1 = (Dali::Vector3 *)jarg1;
7004   result = (float) ((arg1)->g);
7005   jresult = result;
7006   return jresult;
7007 }
7008
7009
7010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7011   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7012   float arg2 ;
7013
7014   arg1 = (Dali::Vector3 *)jarg1;
7015   arg2 = (float)jarg2;
7016   if (arg1) (arg1)->z = arg2;
7017 }
7018
7019
7020 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7021   float jresult ;
7022   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7023   float result;
7024
7025   arg1 = (Dali::Vector3 *)jarg1;
7026   result = (float) ((arg1)->z);
7027   jresult = result;
7028   return jresult;
7029 }
7030
7031
7032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7033   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7034   float arg2 ;
7035
7036   arg1 = (Dali::Vector3 *)jarg1;
7037   arg2 = (float)jarg2;
7038   if (arg1) (arg1)->depth = arg2;
7039 }
7040
7041
7042 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7043   float jresult ;
7044   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7045   float result;
7046
7047   arg1 = (Dali::Vector3 *)jarg1;
7048   result = (float) ((arg1)->depth);
7049   jresult = result;
7050   return jresult;
7051 }
7052
7053
7054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7055   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7056   float arg2 ;
7057
7058   arg1 = (Dali::Vector3 *)jarg1;
7059   arg2 = (float)jarg2;
7060   if (arg1) (arg1)->b = arg2;
7061 }
7062
7063
7064 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7065   float jresult ;
7066   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7067   float result;
7068
7069   arg1 = (Dali::Vector3 *)jarg1;
7070   result = (float) ((arg1)->b);
7071   jresult = result;
7072   return jresult;
7073 }
7074
7075
7076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7077   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7078
7079   arg1 = (Dali::Vector3 *)jarg1;
7080   {
7081     try {
7082       delete arg1;
7083     } catch (std::out_of_range& e) {
7084       {
7085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7086       };
7087     } catch (std::exception& e) {
7088       {
7089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7090       };
7091     } catch (Dali::DaliException e) {
7092       {
7093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7094       };
7095     } catch (...) {
7096       {
7097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7098       };
7099     }
7100   }
7101
7102 }
7103
7104
7105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7106   void * jresult ;
7107   Dali::Vector3 *arg1 = 0 ;
7108   Dali::Vector3 *arg2 = 0 ;
7109   Dali::Vector3 result;
7110
7111   arg1 = (Dali::Vector3 *)jarg1;
7112   if (!arg1) {
7113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7114     return 0;
7115   }
7116   arg2 = (Dali::Vector3 *)jarg2;
7117   if (!arg2) {
7118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7119     return 0;
7120   }
7121   {
7122     try {
7123       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7124     } catch (std::out_of_range& e) {
7125       {
7126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7127       };
7128     } catch (std::exception& e) {
7129       {
7130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7131       };
7132     } catch (Dali::DaliException e) {
7133       {
7134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7135       };
7136     } catch (...) {
7137       {
7138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7139       };
7140     }
7141   }
7142
7143   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7144   return jresult;
7145 }
7146
7147
7148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7149   void * jresult ;
7150   Dali::Vector3 *arg1 = 0 ;
7151   Dali::Vector3 *arg2 = 0 ;
7152   Dali::Vector3 result;
7153
7154   arg1 = (Dali::Vector3 *)jarg1;
7155   if (!arg1) {
7156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7157     return 0;
7158   }
7159   arg2 = (Dali::Vector3 *)jarg2;
7160   if (!arg2) {
7161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7162     return 0;
7163   }
7164   {
7165     try {
7166       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7167     } catch (std::out_of_range& e) {
7168       {
7169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7170       };
7171     } catch (std::exception& e) {
7172       {
7173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7174       };
7175     } catch (Dali::DaliException e) {
7176       {
7177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7178       };
7179     } catch (...) {
7180       {
7181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7182       };
7183     }
7184   }
7185
7186   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7187   return jresult;
7188 }
7189
7190
7191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7192   void * jresult ;
7193   Dali::Vector3 *arg1 = 0 ;
7194   float *arg2 = 0 ;
7195   float *arg3 = 0 ;
7196   float temp2 ;
7197   float temp3 ;
7198   Dali::Vector3 result;
7199
7200   arg1 = (Dali::Vector3 *)jarg1;
7201   if (!arg1) {
7202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7203     return 0;
7204   }
7205   temp2 = (float)jarg2;
7206   arg2 = &temp2;
7207   temp3 = (float)jarg3;
7208   arg3 = &temp3;
7209   {
7210     try {
7211       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7212     } catch (std::out_of_range& e) {
7213       {
7214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7215       };
7216     } catch (std::exception& e) {
7217       {
7218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7219       };
7220     } catch (Dali::DaliException e) {
7221       {
7222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7223       };
7224     } catch (...) {
7225       {
7226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7227       };
7228     }
7229   }
7230
7231   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7232   return jresult;
7233 }
7234
7235
7236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7237   void * jresult ;
7238   Dali::Vector4 *result = 0 ;
7239
7240   {
7241     try {
7242       result = (Dali::Vector4 *)new Dali::Vector4();
7243     } catch (std::out_of_range& e) {
7244       {
7245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7246       };
7247     } catch (std::exception& e) {
7248       {
7249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7250       };
7251     } catch (Dali::DaliException e) {
7252       {
7253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7254       };
7255     } catch (...) {
7256       {
7257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7258       };
7259     }
7260   }
7261
7262   jresult = (void *)result;
7263   return jresult;
7264 }
7265
7266
7267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7268   void * jresult ;
7269   float arg1 ;
7270   float arg2 ;
7271   float arg3 ;
7272   float arg4 ;
7273   Dali::Vector4 *result = 0 ;
7274
7275   arg1 = (float)jarg1;
7276   arg2 = (float)jarg2;
7277   arg3 = (float)jarg3;
7278   arg4 = (float)jarg4;
7279   {
7280     try {
7281       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7282     } catch (std::out_of_range& e) {
7283       {
7284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7285       };
7286     } catch (std::exception& e) {
7287       {
7288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7289       };
7290     } catch (Dali::DaliException e) {
7291       {
7292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7293       };
7294     } catch (...) {
7295       {
7296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7297       };
7298     }
7299   }
7300
7301   jresult = (void *)result;
7302   return jresult;
7303 }
7304
7305
7306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7307   void * jresult ;
7308   float *arg1 = (float *) 0 ;
7309   Dali::Vector4 *result = 0 ;
7310
7311   arg1 = jarg1;
7312   {
7313     try {
7314       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7315     } catch (std::out_of_range& e) {
7316       {
7317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7318       };
7319     } catch (std::exception& e) {
7320       {
7321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7322       };
7323     } catch (Dali::DaliException e) {
7324       {
7325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7326       };
7327     } catch (...) {
7328       {
7329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7330       };
7331     }
7332   }
7333
7334   jresult = (void *)result;
7335
7336
7337   return jresult;
7338 }
7339
7340
7341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7342   void * jresult ;
7343   Dali::Vector2 *arg1 = 0 ;
7344   Dali::Vector4 *result = 0 ;
7345
7346   arg1 = (Dali::Vector2 *)jarg1;
7347   if (!arg1) {
7348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7349     return 0;
7350   }
7351   {
7352     try {
7353       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7354     } catch (std::out_of_range& e) {
7355       {
7356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7357       };
7358     } catch (std::exception& e) {
7359       {
7360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7361       };
7362     } catch (Dali::DaliException e) {
7363       {
7364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7365       };
7366     } catch (...) {
7367       {
7368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7369       };
7370     }
7371   }
7372
7373   jresult = (void *)result;
7374   return jresult;
7375 }
7376
7377
7378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7379   void * jresult ;
7380   Dali::Vector3 *arg1 = 0 ;
7381   Dali::Vector4 *result = 0 ;
7382
7383   arg1 = (Dali::Vector3 *)jarg1;
7384   if (!arg1) {
7385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7386     return 0;
7387   }
7388   {
7389     try {
7390       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7391     } catch (std::out_of_range& e) {
7392       {
7393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7394       };
7395     } catch (std::exception& e) {
7396       {
7397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7398       };
7399     } catch (Dali::DaliException e) {
7400       {
7401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7402       };
7403     } catch (...) {
7404       {
7405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7406       };
7407     }
7408   }
7409
7410   jresult = (void *)result;
7411   return jresult;
7412 }
7413
7414
7415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7416   void * jresult ;
7417   Dali::Vector4 *result = 0 ;
7418
7419   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7420   jresult = (void *)result;
7421   return jresult;
7422 }
7423
7424
7425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7426   void * jresult ;
7427   Dali::Vector4 *result = 0 ;
7428
7429   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7430   jresult = (void *)result;
7431   return jresult;
7432 }
7433
7434
7435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7436   void * jresult ;
7437   Dali::Vector4 *result = 0 ;
7438
7439   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7440   jresult = (void *)result;
7441   return jresult;
7442 }
7443
7444
7445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7446   void * jresult ;
7447   Dali::Vector4 *result = 0 ;
7448
7449   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7450   jresult = (void *)result;
7451   return jresult;
7452 }
7453
7454
7455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7456   void * jresult ;
7457   Dali::Vector4 *result = 0 ;
7458
7459   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7460   jresult = (void *)result;
7461   return jresult;
7462 }
7463
7464
7465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7466   void * jresult ;
7467   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7468   float *arg2 = (float *) 0 ;
7469   Dali::Vector4 *result = 0 ;
7470
7471   arg1 = (Dali::Vector4 *)jarg1;
7472   arg2 = jarg2;
7473   {
7474     try {
7475       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7476     } catch (std::out_of_range& e) {
7477       {
7478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7479       };
7480     } catch (std::exception& e) {
7481       {
7482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7483       };
7484     } catch (Dali::DaliException e) {
7485       {
7486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7487       };
7488     } catch (...) {
7489       {
7490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7491       };
7492     }
7493   }
7494
7495   jresult = (void *)result;
7496
7497
7498   return jresult;
7499 }
7500
7501
7502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7503   void * jresult ;
7504   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7505   Dali::Vector2 *arg2 = 0 ;
7506   Dali::Vector4 *result = 0 ;
7507
7508   arg1 = (Dali::Vector4 *)jarg1;
7509   arg2 = (Dali::Vector2 *)jarg2;
7510   if (!arg2) {
7511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7512     return 0;
7513   }
7514   {
7515     try {
7516       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7517     } catch (std::out_of_range& e) {
7518       {
7519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7520       };
7521     } catch (std::exception& e) {
7522       {
7523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7524       };
7525     } catch (Dali::DaliException e) {
7526       {
7527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7528       };
7529     } catch (...) {
7530       {
7531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7532       };
7533     }
7534   }
7535
7536   jresult = (void *)result;
7537   return jresult;
7538 }
7539
7540
7541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7542   void * jresult ;
7543   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7544   Dali::Vector3 *arg2 = 0 ;
7545   Dali::Vector4 *result = 0 ;
7546
7547   arg1 = (Dali::Vector4 *)jarg1;
7548   arg2 = (Dali::Vector3 *)jarg2;
7549   if (!arg2) {
7550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7551     return 0;
7552   }
7553   {
7554     try {
7555       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7556     } catch (std::out_of_range& e) {
7557       {
7558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7559       };
7560     } catch (std::exception& e) {
7561       {
7562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7563       };
7564     } catch (Dali::DaliException e) {
7565       {
7566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7567       };
7568     } catch (...) {
7569       {
7570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7571       };
7572     }
7573   }
7574
7575   jresult = (void *)result;
7576   return jresult;
7577 }
7578
7579
7580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7581   void * jresult ;
7582   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7583   Dali::Vector4 *arg2 = 0 ;
7584   Dali::Vector4 result;
7585
7586   arg1 = (Dali::Vector4 *)jarg1;
7587   arg2 = (Dali::Vector4 *)jarg2;
7588   if (!arg2) {
7589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7590     return 0;
7591   }
7592   {
7593     try {
7594       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7595     } catch (std::out_of_range& e) {
7596       {
7597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7598       };
7599     } catch (std::exception& e) {
7600       {
7601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7602       };
7603     } catch (Dali::DaliException e) {
7604       {
7605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7606       };
7607     } catch (...) {
7608       {
7609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7610       };
7611     }
7612   }
7613
7614   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7615   return jresult;
7616 }
7617
7618
7619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7620   void * jresult ;
7621   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7622   Dali::Vector4 *arg2 = 0 ;
7623   Dali::Vector4 *result = 0 ;
7624
7625   arg1 = (Dali::Vector4 *)jarg1;
7626   arg2 = (Dali::Vector4 *)jarg2;
7627   if (!arg2) {
7628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7629     return 0;
7630   }
7631   {
7632     try {
7633       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7634     } catch (std::out_of_range& e) {
7635       {
7636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7637       };
7638     } catch (std::exception& e) {
7639       {
7640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7641       };
7642     } catch (Dali::DaliException e) {
7643       {
7644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7645       };
7646     } catch (...) {
7647       {
7648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7649       };
7650     }
7651   }
7652
7653   jresult = (void *)result;
7654   return jresult;
7655 }
7656
7657
7658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7659   void * jresult ;
7660   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7661   Dali::Vector4 *arg2 = 0 ;
7662   Dali::Vector4 result;
7663
7664   arg1 = (Dali::Vector4 *)jarg1;
7665   arg2 = (Dali::Vector4 *)jarg2;
7666   if (!arg2) {
7667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7668     return 0;
7669   }
7670   {
7671     try {
7672       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7673     } catch (std::out_of_range& e) {
7674       {
7675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7676       };
7677     } catch (std::exception& e) {
7678       {
7679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7680       };
7681     } catch (Dali::DaliException e) {
7682       {
7683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7684       };
7685     } catch (...) {
7686       {
7687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7688       };
7689     }
7690   }
7691
7692   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7693   return jresult;
7694 }
7695
7696
7697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7698   void * jresult ;
7699   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7700   Dali::Vector4 *arg2 = 0 ;
7701   Dali::Vector4 *result = 0 ;
7702
7703   arg1 = (Dali::Vector4 *)jarg1;
7704   arg2 = (Dali::Vector4 *)jarg2;
7705   if (!arg2) {
7706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7707     return 0;
7708   }
7709   {
7710     try {
7711       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7712     } catch (std::out_of_range& e) {
7713       {
7714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7715       };
7716     } catch (std::exception& e) {
7717       {
7718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7719       };
7720     } catch (Dali::DaliException e) {
7721       {
7722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7723       };
7724     } catch (...) {
7725       {
7726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7727       };
7728     }
7729   }
7730
7731   jresult = (void *)result;
7732   return jresult;
7733 }
7734
7735
7736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7737   void * jresult ;
7738   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7739   Dali::Vector4 *arg2 = 0 ;
7740   Dali::Vector4 result;
7741
7742   arg1 = (Dali::Vector4 *)jarg1;
7743   arg2 = (Dali::Vector4 *)jarg2;
7744   if (!arg2) {
7745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7746     return 0;
7747   }
7748   {
7749     try {
7750       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7751     } catch (std::out_of_range& e) {
7752       {
7753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7754       };
7755     } catch (std::exception& e) {
7756       {
7757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7758       };
7759     } catch (Dali::DaliException e) {
7760       {
7761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7762       };
7763     } catch (...) {
7764       {
7765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7766       };
7767     }
7768   }
7769
7770   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7771   return jresult;
7772 }
7773
7774
7775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7776   void * jresult ;
7777   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7778   float arg2 ;
7779   Dali::Vector4 result;
7780
7781   arg1 = (Dali::Vector4 *)jarg1;
7782   arg2 = (float)jarg2;
7783   {
7784     try {
7785       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7786     } catch (std::out_of_range& e) {
7787       {
7788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7789       };
7790     } catch (std::exception& e) {
7791       {
7792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7793       };
7794     } catch (Dali::DaliException e) {
7795       {
7796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7797       };
7798     } catch (...) {
7799       {
7800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7801       };
7802     }
7803   }
7804
7805   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7806   return jresult;
7807 }
7808
7809
7810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7811   void * jresult ;
7812   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7813   Dali::Vector4 *arg2 = 0 ;
7814   Dali::Vector4 *result = 0 ;
7815
7816   arg1 = (Dali::Vector4 *)jarg1;
7817   arg2 = (Dali::Vector4 *)jarg2;
7818   if (!arg2) {
7819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7820     return 0;
7821   }
7822   {
7823     try {
7824       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7825     } catch (std::out_of_range& e) {
7826       {
7827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7828       };
7829     } catch (std::exception& e) {
7830       {
7831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7832       };
7833     } catch (Dali::DaliException e) {
7834       {
7835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7836       };
7837     } catch (...) {
7838       {
7839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7840       };
7841     }
7842   }
7843
7844   jresult = (void *)result;
7845   return jresult;
7846 }
7847
7848
7849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7850   void * jresult ;
7851   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7852   float arg2 ;
7853   Dali::Vector4 *result = 0 ;
7854
7855   arg1 = (Dali::Vector4 *)jarg1;
7856   arg2 = (float)jarg2;
7857   {
7858     try {
7859       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7860     } catch (std::out_of_range& e) {
7861       {
7862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7863       };
7864     } catch (std::exception& e) {
7865       {
7866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7867       };
7868     } catch (Dali::DaliException e) {
7869       {
7870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7871       };
7872     } catch (...) {
7873       {
7874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7875       };
7876     }
7877   }
7878
7879   jresult = (void *)result;
7880   return jresult;
7881 }
7882
7883
7884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7885   void * jresult ;
7886   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7887   Dali::Vector4 *arg2 = 0 ;
7888   Dali::Vector4 result;
7889
7890   arg1 = (Dali::Vector4 *)jarg1;
7891   arg2 = (Dali::Vector4 *)jarg2;
7892   if (!arg2) {
7893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7894     return 0;
7895   }
7896   {
7897     try {
7898       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7899     } catch (std::out_of_range& e) {
7900       {
7901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7902       };
7903     } catch (std::exception& e) {
7904       {
7905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7906       };
7907     } catch (Dali::DaliException e) {
7908       {
7909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7910       };
7911     } catch (...) {
7912       {
7913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7914       };
7915     }
7916   }
7917
7918   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7919   return jresult;
7920 }
7921
7922
7923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7924   void * jresult ;
7925   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7926   float arg2 ;
7927   Dali::Vector4 result;
7928
7929   arg1 = (Dali::Vector4 *)jarg1;
7930   arg2 = (float)jarg2;
7931   {
7932     try {
7933       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7934     } catch (std::out_of_range& e) {
7935       {
7936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7937       };
7938     } catch (std::exception& e) {
7939       {
7940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7941       };
7942     } catch (Dali::DaliException e) {
7943       {
7944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7945       };
7946     } catch (...) {
7947       {
7948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7949       };
7950     }
7951   }
7952
7953   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7954   return jresult;
7955 }
7956
7957
7958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7959   void * jresult ;
7960   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7961   Dali::Vector4 *arg2 = 0 ;
7962   Dali::Vector4 *result = 0 ;
7963
7964   arg1 = (Dali::Vector4 *)jarg1;
7965   arg2 = (Dali::Vector4 *)jarg2;
7966   if (!arg2) {
7967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7968     return 0;
7969   }
7970   {
7971     try {
7972       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7973     } catch (std::out_of_range& e) {
7974       {
7975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7976       };
7977     } catch (std::exception& e) {
7978       {
7979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7980       };
7981     } catch (Dali::DaliException e) {
7982       {
7983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7984       };
7985     } catch (...) {
7986       {
7987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7988       };
7989     }
7990   }
7991
7992   jresult = (void *)result;
7993   return jresult;
7994 }
7995
7996
7997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7998   void * jresult ;
7999   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8000   float arg2 ;
8001   Dali::Vector4 *result = 0 ;
8002
8003   arg1 = (Dali::Vector4 *)jarg1;
8004   arg2 = (float)jarg2;
8005   {
8006     try {
8007       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8008     } catch (std::out_of_range& e) {
8009       {
8010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8011       };
8012     } catch (std::exception& e) {
8013       {
8014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8015       };
8016     } catch (Dali::DaliException e) {
8017       {
8018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8019       };
8020     } catch (...) {
8021       {
8022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8023       };
8024     }
8025   }
8026
8027   jresult = (void *)result;
8028   return jresult;
8029 }
8030
8031
8032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8033   void * jresult ;
8034   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8035   Dali::Vector4 result;
8036
8037   arg1 = (Dali::Vector4 *)jarg1;
8038   {
8039     try {
8040       result = ((Dali::Vector4 const *)arg1)->operator -();
8041     } catch (std::out_of_range& e) {
8042       {
8043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8044       };
8045     } catch (std::exception& e) {
8046       {
8047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8048       };
8049     } catch (Dali::DaliException e) {
8050       {
8051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8052       };
8053     } catch (...) {
8054       {
8055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8056       };
8057     }
8058   }
8059
8060   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8061   return jresult;
8062 }
8063
8064
8065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8066   unsigned int jresult ;
8067   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8068   Dali::Vector4 *arg2 = 0 ;
8069   bool result;
8070
8071   arg1 = (Dali::Vector4 *)jarg1;
8072   arg2 = (Dali::Vector4 *)jarg2;
8073   if (!arg2) {
8074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8075     return 0;
8076   }
8077   {
8078     try {
8079       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8080     } catch (std::out_of_range& e) {
8081       {
8082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8083       };
8084     } catch (std::exception& e) {
8085       {
8086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8087       };
8088     } catch (Dali::DaliException e) {
8089       {
8090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8091       };
8092     } catch (...) {
8093       {
8094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8095       };
8096     }
8097   }
8098
8099   jresult = result;
8100   return jresult;
8101 }
8102
8103
8104 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8105   unsigned int jresult ;
8106   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8107   Dali::Vector4 *arg2 = 0 ;
8108   bool result;
8109
8110   arg1 = (Dali::Vector4 *)jarg1;
8111   arg2 = (Dali::Vector4 *)jarg2;
8112   if (!arg2) {
8113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8114     return 0;
8115   }
8116   {
8117     try {
8118       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8119     } catch (std::out_of_range& e) {
8120       {
8121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8122       };
8123     } catch (std::exception& e) {
8124       {
8125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8126       };
8127     } catch (Dali::DaliException e) {
8128       {
8129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8130       };
8131     } catch (...) {
8132       {
8133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8134       };
8135     }
8136   }
8137
8138   jresult = result;
8139   return jresult;
8140 }
8141
8142
8143 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8144   float jresult ;
8145   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8146   unsigned int arg2 ;
8147   float *result = 0 ;
8148
8149   arg1 = (Dali::Vector4 *)jarg1;
8150   arg2 = (unsigned int)jarg2;
8151   {
8152     try {
8153       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8154     } catch (std::out_of_range& e) {
8155       {
8156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8157       };
8158     } catch (std::exception& e) {
8159       {
8160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8161       };
8162     } catch (Dali::DaliException e) {
8163       {
8164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8165       };
8166     } catch (...) {
8167       {
8168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8169       };
8170     }
8171   }
8172
8173   jresult = *result;
8174   return jresult;
8175 }
8176
8177
8178 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8179   float jresult ;
8180   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8181   Dali::Vector3 *arg2 = 0 ;
8182   float result;
8183
8184   arg1 = (Dali::Vector4 *)jarg1;
8185   arg2 = (Dali::Vector3 *)jarg2;
8186   if (!arg2) {
8187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8188     return 0;
8189   }
8190   {
8191     try {
8192       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8193     } catch (std::out_of_range& e) {
8194       {
8195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8196       };
8197     } catch (std::exception& e) {
8198       {
8199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8200       };
8201     } catch (Dali::DaliException e) {
8202       {
8203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8204       };
8205     } catch (...) {
8206       {
8207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8208       };
8209     }
8210   }
8211
8212   jresult = result;
8213   return jresult;
8214 }
8215
8216
8217 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8218   float jresult ;
8219   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8220   Dali::Vector4 *arg2 = 0 ;
8221   float result;
8222
8223   arg1 = (Dali::Vector4 *)jarg1;
8224   arg2 = (Dali::Vector4 *)jarg2;
8225   if (!arg2) {
8226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8227     return 0;
8228   }
8229   {
8230     try {
8231       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8232     } catch (std::out_of_range& e) {
8233       {
8234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8235       };
8236     } catch (std::exception& e) {
8237       {
8238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8239       };
8240     } catch (Dali::DaliException e) {
8241       {
8242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8243       };
8244     } catch (...) {
8245       {
8246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8247       };
8248     }
8249   }
8250
8251   jresult = result;
8252   return jresult;
8253 }
8254
8255
8256 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8257   float jresult ;
8258   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8259   Dali::Vector4 *arg2 = 0 ;
8260   float result;
8261
8262   arg1 = (Dali::Vector4 *)jarg1;
8263   arg2 = (Dali::Vector4 *)jarg2;
8264   if (!arg2) {
8265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8266     return 0;
8267   }
8268   {
8269     try {
8270       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8271     } catch (std::out_of_range& e) {
8272       {
8273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8274       };
8275     } catch (std::exception& e) {
8276       {
8277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8278       };
8279     } catch (Dali::DaliException e) {
8280       {
8281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8282       };
8283     } catch (...) {
8284       {
8285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8286       };
8287     }
8288   }
8289
8290   jresult = result;
8291   return jresult;
8292 }
8293
8294
8295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8296   void * jresult ;
8297   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8298   Dali::Vector4 *arg2 = 0 ;
8299   Dali::Vector4 result;
8300
8301   arg1 = (Dali::Vector4 *)jarg1;
8302   arg2 = (Dali::Vector4 *)jarg2;
8303   if (!arg2) {
8304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8305     return 0;
8306   }
8307   {
8308     try {
8309       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8310     } catch (std::out_of_range& e) {
8311       {
8312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8313       };
8314     } catch (std::exception& e) {
8315       {
8316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8317       };
8318     } catch (Dali::DaliException e) {
8319       {
8320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8321       };
8322     } catch (...) {
8323       {
8324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8325       };
8326     }
8327   }
8328
8329   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8330   return jresult;
8331 }
8332
8333
8334 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8335   float jresult ;
8336   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8337   float result;
8338
8339   arg1 = (Dali::Vector4 *)jarg1;
8340   {
8341     try {
8342       result = (float)((Dali::Vector4 const *)arg1)->Length();
8343     } catch (std::out_of_range& e) {
8344       {
8345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8346       };
8347     } catch (std::exception& e) {
8348       {
8349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8350       };
8351     } catch (Dali::DaliException e) {
8352       {
8353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8354       };
8355     } catch (...) {
8356       {
8357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8358       };
8359     }
8360   }
8361
8362   jresult = result;
8363   return jresult;
8364 }
8365
8366
8367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8368   float jresult ;
8369   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8370   float result;
8371
8372   arg1 = (Dali::Vector4 *)jarg1;
8373   {
8374     try {
8375       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8376     } catch (std::out_of_range& e) {
8377       {
8378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8379       };
8380     } catch (std::exception& e) {
8381       {
8382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8383       };
8384     } catch (Dali::DaliException e) {
8385       {
8386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8387       };
8388     } catch (...) {
8389       {
8390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8391       };
8392     }
8393   }
8394
8395   jresult = result;
8396   return jresult;
8397 }
8398
8399
8400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8401   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8402
8403   arg1 = (Dali::Vector4 *)jarg1;
8404   {
8405     try {
8406       (arg1)->Normalize();
8407     } catch (std::out_of_range& e) {
8408       {
8409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8410       };
8411     } catch (std::exception& e) {
8412       {
8413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8414       };
8415     } catch (Dali::DaliException e) {
8416       {
8417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8418       };
8419     } catch (...) {
8420       {
8421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8422       };
8423     }
8424   }
8425
8426 }
8427
8428
8429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8430   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8431   Dali::Vector4 *arg2 = 0 ;
8432   Dali::Vector4 *arg3 = 0 ;
8433
8434   arg1 = (Dali::Vector4 *)jarg1;
8435   arg2 = (Dali::Vector4 *)jarg2;
8436   if (!arg2) {
8437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8438     return ;
8439   }
8440   arg3 = (Dali::Vector4 *)jarg3;
8441   if (!arg3) {
8442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8443     return ;
8444   }
8445   {
8446     try {
8447       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8448     } catch (std::out_of_range& e) {
8449       {
8450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8451       };
8452     } catch (std::exception& e) {
8453       {
8454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8455       };
8456     } catch (Dali::DaliException e) {
8457       {
8458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8459       };
8460     } catch (...) {
8461       {
8462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8463       };
8464     }
8465   }
8466
8467 }
8468
8469
8470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8471   void * jresult ;
8472   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8473   float *result = 0 ;
8474
8475   arg1 = (Dali::Vector4 *)jarg1;
8476   {
8477     try {
8478       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8479     } catch (std::out_of_range& e) {
8480       {
8481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8482       };
8483     } catch (std::exception& e) {
8484       {
8485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8486       };
8487     } catch (Dali::DaliException e) {
8488       {
8489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8490       };
8491     } catch (...) {
8492       {
8493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8494       };
8495     }
8496   }
8497
8498   jresult = (void *)result;
8499   return jresult;
8500 }
8501
8502
8503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8504   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8505   float arg2 ;
8506
8507   arg1 = (Dali::Vector4 *)jarg1;
8508   arg2 = (float)jarg2;
8509   if (arg1) (arg1)->x = arg2;
8510 }
8511
8512
8513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8514   float jresult ;
8515   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8516   float result;
8517
8518   arg1 = (Dali::Vector4 *)jarg1;
8519   result = (float) ((arg1)->x);
8520   jresult = result;
8521   return jresult;
8522 }
8523
8524
8525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8526   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8527   float arg2 ;
8528
8529   arg1 = (Dali::Vector4 *)jarg1;
8530   arg2 = (float)jarg2;
8531   if (arg1) (arg1)->r = arg2;
8532 }
8533
8534
8535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8536   float jresult ;
8537   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8538   float result;
8539
8540   arg1 = (Dali::Vector4 *)jarg1;
8541   result = (float) ((arg1)->r);
8542   jresult = result;
8543   return jresult;
8544 }
8545
8546
8547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8548   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8549   float arg2 ;
8550
8551   arg1 = (Dali::Vector4 *)jarg1;
8552   arg2 = (float)jarg2;
8553   if (arg1) (arg1)->s = arg2;
8554 }
8555
8556
8557 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8558   float jresult ;
8559   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8560   float result;
8561
8562   arg1 = (Dali::Vector4 *)jarg1;
8563   result = (float) ((arg1)->s);
8564   jresult = result;
8565   return jresult;
8566 }
8567
8568
8569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8570   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8571   float arg2 ;
8572
8573   arg1 = (Dali::Vector4 *)jarg1;
8574   arg2 = (float)jarg2;
8575   if (arg1) (arg1)->y = arg2;
8576 }
8577
8578
8579 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8580   float jresult ;
8581   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8582   float result;
8583
8584   arg1 = (Dali::Vector4 *)jarg1;
8585   result = (float) ((arg1)->y);
8586   jresult = result;
8587   return jresult;
8588 }
8589
8590
8591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8592   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8593   float arg2 ;
8594
8595   arg1 = (Dali::Vector4 *)jarg1;
8596   arg2 = (float)jarg2;
8597   if (arg1) (arg1)->g = arg2;
8598 }
8599
8600
8601 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8602   float jresult ;
8603   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8604   float result;
8605
8606   arg1 = (Dali::Vector4 *)jarg1;
8607   result = (float) ((arg1)->g);
8608   jresult = result;
8609   return jresult;
8610 }
8611
8612
8613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8614   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8615   float arg2 ;
8616
8617   arg1 = (Dali::Vector4 *)jarg1;
8618   arg2 = (float)jarg2;
8619   if (arg1) (arg1)->t = arg2;
8620 }
8621
8622
8623 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8624   float jresult ;
8625   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8626   float result;
8627
8628   arg1 = (Dali::Vector4 *)jarg1;
8629   result = (float) ((arg1)->t);
8630   jresult = result;
8631   return jresult;
8632 }
8633
8634
8635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8636   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8637   float arg2 ;
8638
8639   arg1 = (Dali::Vector4 *)jarg1;
8640   arg2 = (float)jarg2;
8641   if (arg1) (arg1)->z = arg2;
8642 }
8643
8644
8645 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8646   float jresult ;
8647   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8648   float result;
8649
8650   arg1 = (Dali::Vector4 *)jarg1;
8651   result = (float) ((arg1)->z);
8652   jresult = result;
8653   return jresult;
8654 }
8655
8656
8657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8658   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8659   float arg2 ;
8660
8661   arg1 = (Dali::Vector4 *)jarg1;
8662   arg2 = (float)jarg2;
8663   if (arg1) (arg1)->b = arg2;
8664 }
8665
8666
8667 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8668   float jresult ;
8669   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8670   float result;
8671
8672   arg1 = (Dali::Vector4 *)jarg1;
8673   result = (float) ((arg1)->b);
8674   jresult = result;
8675   return jresult;
8676 }
8677
8678
8679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8680   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8681   float arg2 ;
8682
8683   arg1 = (Dali::Vector4 *)jarg1;
8684   arg2 = (float)jarg2;
8685   if (arg1) (arg1)->p = arg2;
8686 }
8687
8688
8689 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8690   float jresult ;
8691   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8692   float result;
8693
8694   arg1 = (Dali::Vector4 *)jarg1;
8695   result = (float) ((arg1)->p);
8696   jresult = result;
8697   return jresult;
8698 }
8699
8700
8701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8702   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8703   float arg2 ;
8704
8705   arg1 = (Dali::Vector4 *)jarg1;
8706   arg2 = (float)jarg2;
8707   if (arg1) (arg1)->w = arg2;
8708 }
8709
8710
8711 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8712   float jresult ;
8713   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8714   float result;
8715
8716   arg1 = (Dali::Vector4 *)jarg1;
8717   result = (float) ((arg1)->w);
8718   jresult = result;
8719   return jresult;
8720 }
8721
8722
8723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8724   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8725   float arg2 ;
8726
8727   arg1 = (Dali::Vector4 *)jarg1;
8728   arg2 = (float)jarg2;
8729   if (arg1) (arg1)->a = arg2;
8730 }
8731
8732
8733 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8734   float jresult ;
8735   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8736   float result;
8737
8738   arg1 = (Dali::Vector4 *)jarg1;
8739   result = (float) ((arg1)->a);
8740   jresult = result;
8741   return jresult;
8742 }
8743
8744
8745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8746   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8747   float arg2 ;
8748
8749   arg1 = (Dali::Vector4 *)jarg1;
8750   arg2 = (float)jarg2;
8751   if (arg1) (arg1)->q = arg2;
8752 }
8753
8754
8755 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8756   float jresult ;
8757   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8758   float result;
8759
8760   arg1 = (Dali::Vector4 *)jarg1;
8761   result = (float) ((arg1)->q);
8762   jresult = result;
8763   return jresult;
8764 }
8765
8766
8767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8768   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8769
8770   arg1 = (Dali::Vector4 *)jarg1;
8771   {
8772     try {
8773       delete arg1;
8774     } catch (std::out_of_range& e) {
8775       {
8776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8777       };
8778     } catch (std::exception& e) {
8779       {
8780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8781       };
8782     } catch (Dali::DaliException e) {
8783       {
8784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8785       };
8786     } catch (...) {
8787       {
8788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8789       };
8790     }
8791   }
8792
8793 }
8794
8795
8796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8797   void * jresult ;
8798   Dali::Vector4 *arg1 = 0 ;
8799   Dali::Vector4 *arg2 = 0 ;
8800   Dali::Vector4 result;
8801
8802   arg1 = (Dali::Vector4 *)jarg1;
8803   if (!arg1) {
8804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8805     return 0;
8806   }
8807   arg2 = (Dali::Vector4 *)jarg2;
8808   if (!arg2) {
8809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8810     return 0;
8811   }
8812   {
8813     try {
8814       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8815     } catch (std::out_of_range& e) {
8816       {
8817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8818       };
8819     } catch (std::exception& e) {
8820       {
8821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8822       };
8823     } catch (Dali::DaliException e) {
8824       {
8825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8826       };
8827     } catch (...) {
8828       {
8829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8830       };
8831     }
8832   }
8833
8834   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8835   return jresult;
8836 }
8837
8838
8839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8840   void * jresult ;
8841   Dali::Vector4 *arg1 = 0 ;
8842   Dali::Vector4 *arg2 = 0 ;
8843   Dali::Vector4 result;
8844
8845   arg1 = (Dali::Vector4 *)jarg1;
8846   if (!arg1) {
8847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8848     return 0;
8849   }
8850   arg2 = (Dali::Vector4 *)jarg2;
8851   if (!arg2) {
8852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8853     return 0;
8854   }
8855   {
8856     try {
8857       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8858     } catch (std::out_of_range& e) {
8859       {
8860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8861       };
8862     } catch (std::exception& e) {
8863       {
8864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8865       };
8866     } catch (Dali::DaliException e) {
8867       {
8868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8869       };
8870     } catch (...) {
8871       {
8872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8873       };
8874     }
8875   }
8876
8877   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8878   return jresult;
8879 }
8880
8881
8882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8883   void * jresult ;
8884   Dali::Vector4 *arg1 = 0 ;
8885   float *arg2 = 0 ;
8886   float *arg3 = 0 ;
8887   float temp2 ;
8888   float temp3 ;
8889   Dali::Vector4 result;
8890
8891   arg1 = (Dali::Vector4 *)jarg1;
8892   if (!arg1) {
8893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8894     return 0;
8895   }
8896   temp2 = (float)jarg2;
8897   arg2 = &temp2;
8898   temp3 = (float)jarg3;
8899   arg3 = &temp3;
8900   {
8901     try {
8902       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8903     } catch (std::out_of_range& e) {
8904       {
8905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8906       };
8907     } catch (std::exception& e) {
8908       {
8909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8910       };
8911     } catch (Dali::DaliException e) {
8912       {
8913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8914       };
8915     } catch (...) {
8916       {
8917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8918       };
8919     }
8920   }
8921
8922   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8923   return jresult;
8924 }
8925
8926
8927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8928   void * jresult ;
8929   Dali::Uint16Pair *result = 0 ;
8930
8931   {
8932     try {
8933       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8934     } catch (std::out_of_range& e) {
8935       {
8936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8937       };
8938     } catch (std::exception& e) {
8939       {
8940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8941       };
8942     } catch (Dali::DaliException e) {
8943       {
8944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8945       };
8946     } catch (...) {
8947       {
8948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8949       };
8950     }
8951   }
8952
8953   jresult = (void *)result;
8954   return jresult;
8955 }
8956
8957
8958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8959   void * jresult ;
8960   uint32_t arg1 ;
8961   uint32_t arg2 ;
8962   Dali::Uint16Pair *result = 0 ;
8963
8964   arg1 = (uint32_t)jarg1;
8965   arg2 = (uint32_t)jarg2;
8966   {
8967     try {
8968       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8969     } catch (std::out_of_range& e) {
8970       {
8971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8972       };
8973     } catch (std::exception& e) {
8974       {
8975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8976       };
8977     } catch (Dali::DaliException e) {
8978       {
8979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8980       };
8981     } catch (...) {
8982       {
8983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8984       };
8985     }
8986   }
8987
8988   jresult = (void *)result;
8989   return jresult;
8990 }
8991
8992
8993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8994   void * jresult ;
8995   Dali::Uint16Pair *arg1 = 0 ;
8996   Dali::Uint16Pair *result = 0 ;
8997
8998   arg1 = (Dali::Uint16Pair *)jarg1;
8999   if (!arg1) {
9000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9001     return 0;
9002   }
9003   {
9004     try {
9005       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9006     } catch (std::out_of_range& e) {
9007       {
9008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9009       };
9010     } catch (std::exception& e) {
9011       {
9012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9013       };
9014     } catch (Dali::DaliException e) {
9015       {
9016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9017       };
9018     } catch (...) {
9019       {
9020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9021       };
9022     }
9023   }
9024
9025   jresult = (void *)result;
9026   return jresult;
9027 }
9028
9029
9030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9031   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9032   uint16_t arg2 ;
9033
9034   arg1 = (Dali::Uint16Pair *)jarg1;
9035   arg2 = (uint16_t)jarg2;
9036   {
9037     try {
9038       (arg1)->SetWidth(arg2);
9039     } catch (std::out_of_range& e) {
9040       {
9041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9042       };
9043     } catch (std::exception& e) {
9044       {
9045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9046       };
9047     } catch (Dali::DaliException e) {
9048       {
9049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9050       };
9051     } catch (...) {
9052       {
9053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9054       };
9055     }
9056   }
9057
9058 }
9059
9060
9061 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9062   unsigned short jresult ;
9063   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9064   uint16_t result;
9065
9066   arg1 = (Dali::Uint16Pair *)jarg1;
9067   {
9068     try {
9069       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9070     } catch (std::out_of_range& e) {
9071       {
9072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9073       };
9074     } catch (std::exception& e) {
9075       {
9076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9077       };
9078     } catch (Dali::DaliException e) {
9079       {
9080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9081       };
9082     } catch (...) {
9083       {
9084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9085       };
9086     }
9087   }
9088
9089   jresult = result;
9090   return jresult;
9091 }
9092
9093
9094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9095   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9096   uint16_t arg2 ;
9097
9098   arg1 = (Dali::Uint16Pair *)jarg1;
9099   arg2 = (uint16_t)jarg2;
9100   {
9101     try {
9102       (arg1)->SetHeight(arg2);
9103     } catch (std::out_of_range& e) {
9104       {
9105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9106       };
9107     } catch (std::exception& e) {
9108       {
9109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9110       };
9111     } catch (Dali::DaliException e) {
9112       {
9113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9114       };
9115     } catch (...) {
9116       {
9117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9118       };
9119     }
9120   }
9121
9122 }
9123
9124
9125 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9126   unsigned short jresult ;
9127   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9128   uint16_t result;
9129
9130   arg1 = (Dali::Uint16Pair *)jarg1;
9131   {
9132     try {
9133       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9134     } catch (std::out_of_range& e) {
9135       {
9136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9137       };
9138     } catch (std::exception& e) {
9139       {
9140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9141       };
9142     } catch (Dali::DaliException e) {
9143       {
9144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9145       };
9146     } catch (...) {
9147       {
9148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9149       };
9150     }
9151   }
9152
9153   jresult = result;
9154   return jresult;
9155 }
9156
9157
9158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9159   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9160   uint16_t arg2 ;
9161
9162   arg1 = (Dali::Uint16Pair *)jarg1;
9163   arg2 = (uint16_t)jarg2;
9164   {
9165     try {
9166       (arg1)->SetX(arg2);
9167     } catch (std::out_of_range& e) {
9168       {
9169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9170       };
9171     } catch (std::exception& e) {
9172       {
9173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9174       };
9175     } catch (Dali::DaliException e) {
9176       {
9177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9178       };
9179     } catch (...) {
9180       {
9181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9182       };
9183     }
9184   }
9185
9186 }
9187
9188
9189 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9190   unsigned short jresult ;
9191   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9192   uint16_t result;
9193
9194   arg1 = (Dali::Uint16Pair *)jarg1;
9195   {
9196     try {
9197       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9198     } catch (std::out_of_range& e) {
9199       {
9200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9201       };
9202     } catch (std::exception& e) {
9203       {
9204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9205       };
9206     } catch (Dali::DaliException e) {
9207       {
9208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9209       };
9210     } catch (...) {
9211       {
9212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9213       };
9214     }
9215   }
9216
9217   jresult = result;
9218   return jresult;
9219 }
9220
9221
9222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9223   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9224   uint16_t arg2 ;
9225
9226   arg1 = (Dali::Uint16Pair *)jarg1;
9227   arg2 = (uint16_t)jarg2;
9228   {
9229     try {
9230       (arg1)->SetY(arg2);
9231     } catch (std::out_of_range& e) {
9232       {
9233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9234       };
9235     } catch (std::exception& e) {
9236       {
9237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9238       };
9239     } catch (Dali::DaliException e) {
9240       {
9241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9242       };
9243     } catch (...) {
9244       {
9245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9246       };
9247     }
9248   }
9249
9250 }
9251
9252
9253 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9254   unsigned short jresult ;
9255   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9256   uint16_t result;
9257
9258   arg1 = (Dali::Uint16Pair *)jarg1;
9259   {
9260     try {
9261       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9262     } catch (std::out_of_range& e) {
9263       {
9264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9265       };
9266     } catch (std::exception& e) {
9267       {
9268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9269       };
9270     } catch (Dali::DaliException e) {
9271       {
9272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9273       };
9274     } catch (...) {
9275       {
9276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9277       };
9278     }
9279   }
9280
9281   jresult = result;
9282   return jresult;
9283 }
9284
9285
9286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9287   void * jresult ;
9288   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9289   Dali::Uint16Pair *arg2 = 0 ;
9290   Dali::Uint16Pair *result = 0 ;
9291
9292   arg1 = (Dali::Uint16Pair *)jarg1;
9293   arg2 = (Dali::Uint16Pair *)jarg2;
9294   if (!arg2) {
9295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9296     return 0;
9297   }
9298   {
9299     try {
9300       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9301     } catch (std::out_of_range& e) {
9302       {
9303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9304       };
9305     } catch (std::exception& e) {
9306       {
9307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9308       };
9309     } catch (Dali::DaliException e) {
9310       {
9311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9312       };
9313     } catch (...) {
9314       {
9315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9316       };
9317     }
9318   }
9319
9320   jresult = (void *)result;
9321   return jresult;
9322 }
9323
9324
9325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9326   unsigned int jresult ;
9327   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9328   Dali::Uint16Pair *arg2 = 0 ;
9329   bool result;
9330
9331   arg1 = (Dali::Uint16Pair *)jarg1;
9332   arg2 = (Dali::Uint16Pair *)jarg2;
9333   if (!arg2) {
9334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9335     return 0;
9336   }
9337   {
9338     try {
9339       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9340     } catch (std::out_of_range& e) {
9341       {
9342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9343       };
9344     } catch (std::exception& e) {
9345       {
9346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9347       };
9348     } catch (Dali::DaliException e) {
9349       {
9350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9351       };
9352     } catch (...) {
9353       {
9354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9355       };
9356     }
9357   }
9358
9359   jresult = result;
9360   return jresult;
9361 }
9362
9363
9364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9365   unsigned int jresult ;
9366   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9367   Dali::Uint16Pair *arg2 = 0 ;
9368   bool result;
9369
9370   arg1 = (Dali::Uint16Pair *)jarg1;
9371   arg2 = (Dali::Uint16Pair *)jarg2;
9372   if (!arg2) {
9373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9374     return 0;
9375   }
9376   {
9377     try {
9378       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9379     } catch (std::out_of_range& e) {
9380       {
9381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9382       };
9383     } catch (std::exception& e) {
9384       {
9385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9386       };
9387     } catch (Dali::DaliException e) {
9388       {
9389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9390       };
9391     } catch (...) {
9392       {
9393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9394       };
9395     }
9396   }
9397
9398   jresult = result;
9399   return jresult;
9400 }
9401
9402
9403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9404   unsigned int jresult ;
9405   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9406   Dali::Uint16Pair *arg2 = 0 ;
9407   bool result;
9408
9409   arg1 = (Dali::Uint16Pair *)jarg1;
9410   arg2 = (Dali::Uint16Pair *)jarg2;
9411   if (!arg2) {
9412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9413     return 0;
9414   }
9415   {
9416     try {
9417       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9418     } catch (std::out_of_range& e) {
9419       {
9420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9421       };
9422     } catch (std::exception& e) {
9423       {
9424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9425       };
9426     } catch (Dali::DaliException e) {
9427       {
9428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9429       };
9430     } catch (...) {
9431       {
9432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9433       };
9434     }
9435   }
9436
9437   jresult = result;
9438   return jresult;
9439 }
9440
9441
9442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9443   unsigned int jresult ;
9444   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9445   Dali::Uint16Pair *arg2 = 0 ;
9446   bool result;
9447
9448   arg1 = (Dali::Uint16Pair *)jarg1;
9449   arg2 = (Dali::Uint16Pair *)jarg2;
9450   if (!arg2) {
9451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9452     return 0;
9453   }
9454   {
9455     try {
9456       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9457     } catch (std::out_of_range& e) {
9458       {
9459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9460       };
9461     } catch (std::exception& e) {
9462       {
9463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9464       };
9465     } catch (Dali::DaliException e) {
9466       {
9467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9468       };
9469     } catch (...) {
9470       {
9471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9472       };
9473     }
9474   }
9475
9476   jresult = result;
9477   return jresult;
9478 }
9479
9480
9481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9482   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9483
9484   arg1 = (Dali::Uint16Pair *)jarg1;
9485   {
9486     try {
9487       delete arg1;
9488     } catch (std::out_of_range& e) {
9489       {
9490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9491       };
9492     } catch (std::exception& e) {
9493       {
9494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9495       };
9496     } catch (Dali::DaliException e) {
9497       {
9498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9499       };
9500     } catch (...) {
9501       {
9502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9503       };
9504     }
9505   }
9506
9507 }
9508
9509
9510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9511   void * jresult ;
9512   Dali::Degree *result = 0 ;
9513
9514   {
9515     try {
9516       result = (Dali::Degree *)new Dali::Degree();
9517     } catch (std::out_of_range& e) {
9518       {
9519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9520       };
9521     } catch (std::exception& e) {
9522       {
9523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9524       };
9525     } catch (Dali::DaliException e) {
9526       {
9527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9528       };
9529     } catch (...) {
9530       {
9531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9532       };
9533     }
9534   }
9535
9536   jresult = (void *)result;
9537   return jresult;
9538 }
9539
9540
9541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9542   void * jresult ;
9543   float arg1 ;
9544   Dali::Degree *result = 0 ;
9545
9546   arg1 = (float)jarg1;
9547   {
9548     try {
9549       result = (Dali::Degree *)new Dali::Degree(arg1);
9550     } catch (std::out_of_range& e) {
9551       {
9552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9553       };
9554     } catch (std::exception& e) {
9555       {
9556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9557       };
9558     } catch (Dali::DaliException e) {
9559       {
9560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9561       };
9562     } catch (...) {
9563       {
9564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9565       };
9566     }
9567   }
9568
9569   jresult = (void *)result;
9570   return jresult;
9571 }
9572
9573
9574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9575   void * jresult ;
9576   Dali::Radian arg1 ;
9577   Dali::Radian *argp1 ;
9578   Dali::Degree *result = 0 ;
9579
9580   argp1 = (Dali::Radian *)jarg1;
9581   if (!argp1) {
9582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9583     return 0;
9584   }
9585   arg1 = *argp1;
9586   {
9587     try {
9588       result = (Dali::Degree *)new Dali::Degree(arg1);
9589     } catch (std::out_of_range& e) {
9590       {
9591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9592       };
9593     } catch (std::exception& e) {
9594       {
9595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9596       };
9597     } catch (Dali::DaliException e) {
9598       {
9599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9600       };
9601     } catch (...) {
9602       {
9603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9604       };
9605     }
9606   }
9607
9608   jresult = (void *)result;
9609   return jresult;
9610 }
9611
9612
9613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9614   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9615   float arg2 ;
9616
9617   arg1 = (Dali::Degree *)jarg1;
9618   arg2 = (float)jarg2;
9619   if (arg1) (arg1)->degree = arg2;
9620 }
9621
9622
9623 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9624   float jresult ;
9625   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9626   float result;
9627
9628   arg1 = (Dali::Degree *)jarg1;
9629   result = (float) ((arg1)->degree);
9630   jresult = result;
9631   return jresult;
9632 }
9633
9634
9635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9636   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9637
9638   arg1 = (Dali::Degree *)jarg1;
9639   {
9640     try {
9641       delete arg1;
9642     } catch (std::out_of_range& e) {
9643       {
9644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9645       };
9646     } catch (std::exception& e) {
9647       {
9648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9649       };
9650     } catch (Dali::DaliException e) {
9651       {
9652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9653       };
9654     } catch (...) {
9655       {
9656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9657       };
9658     }
9659   }
9660
9661 }
9662
9663
9664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9665   void * jresult ;
9666   Dali::Radian *result = 0 ;
9667
9668   result = (Dali::Radian *)&Dali::ANGLE_360;
9669   jresult = (void *)result;
9670   return jresult;
9671 }
9672
9673
9674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9675   void * jresult ;
9676   Dali::Radian *result = 0 ;
9677
9678   result = (Dali::Radian *)&Dali::ANGLE_315;
9679   jresult = (void *)result;
9680   return jresult;
9681 }
9682
9683
9684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9685   void * jresult ;
9686   Dali::Radian *result = 0 ;
9687
9688   result = (Dali::Radian *)&Dali::ANGLE_270;
9689   jresult = (void *)result;
9690   return jresult;
9691 }
9692
9693
9694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9695   void * jresult ;
9696   Dali::Radian *result = 0 ;
9697
9698   result = (Dali::Radian *)&Dali::ANGLE_225;
9699   jresult = (void *)result;
9700   return jresult;
9701 }
9702
9703
9704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9705   void * jresult ;
9706   Dali::Radian *result = 0 ;
9707
9708   result = (Dali::Radian *)&Dali::ANGLE_180;
9709   jresult = (void *)result;
9710   return jresult;
9711 }
9712
9713
9714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9715   void * jresult ;
9716   Dali::Radian *result = 0 ;
9717
9718   result = (Dali::Radian *)&Dali::ANGLE_135;
9719   jresult = (void *)result;
9720   return jresult;
9721 }
9722
9723
9724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9725   void * jresult ;
9726   Dali::Radian *result = 0 ;
9727
9728   result = (Dali::Radian *)&Dali::ANGLE_120;
9729   jresult = (void *)result;
9730   return jresult;
9731 }
9732
9733
9734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9735   void * jresult ;
9736   Dali::Radian *result = 0 ;
9737
9738   result = (Dali::Radian *)&Dali::ANGLE_90;
9739   jresult = (void *)result;
9740   return jresult;
9741 }
9742
9743
9744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9745   void * jresult ;
9746   Dali::Radian *result = 0 ;
9747
9748   result = (Dali::Radian *)&Dali::ANGLE_60;
9749   jresult = (void *)result;
9750   return jresult;
9751 }
9752
9753
9754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9755   void * jresult ;
9756   Dali::Radian *result = 0 ;
9757
9758   result = (Dali::Radian *)&Dali::ANGLE_45;
9759   jresult = (void *)result;
9760   return jresult;
9761 }
9762
9763
9764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9765   void * jresult ;
9766   Dali::Radian *result = 0 ;
9767
9768   result = (Dali::Radian *)&Dali::ANGLE_30;
9769   jresult = (void *)result;
9770   return jresult;
9771 }
9772
9773
9774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9775   void * jresult ;
9776   Dali::Radian *result = 0 ;
9777
9778   result = (Dali::Radian *)&Dali::ANGLE_0;
9779   jresult = (void *)result;
9780   return jresult;
9781 }
9782
9783
9784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9785   unsigned int jresult ;
9786   Dali::Degree *arg1 = 0 ;
9787   Dali::Degree *arg2 = 0 ;
9788   bool result;
9789
9790   arg1 = (Dali::Degree *)jarg1;
9791   if (!arg1) {
9792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9793     return 0;
9794   }
9795   arg2 = (Dali::Degree *)jarg2;
9796   if (!arg2) {
9797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9798     return 0;
9799   }
9800   {
9801     try {
9802       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9803     } catch (std::out_of_range& e) {
9804       {
9805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9806       };
9807     } catch (std::exception& e) {
9808       {
9809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9810       };
9811     } catch (Dali::DaliException e) {
9812       {
9813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9814       };
9815     } catch (...) {
9816       {
9817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9818       };
9819     }
9820   }
9821
9822   jresult = result;
9823   return jresult;
9824 }
9825
9826
9827 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9828   unsigned int jresult ;
9829   Dali::Degree *arg1 = 0 ;
9830   Dali::Degree *arg2 = 0 ;
9831   bool result;
9832
9833   arg1 = (Dali::Degree *)jarg1;
9834   if (!arg1) {
9835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9836     return 0;
9837   }
9838   arg2 = (Dali::Degree *)jarg2;
9839   if (!arg2) {
9840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9841     return 0;
9842   }
9843   {
9844     try {
9845       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9846     } catch (std::out_of_range& e) {
9847       {
9848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9849       };
9850     } catch (std::exception& e) {
9851       {
9852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9853       };
9854     } catch (Dali::DaliException e) {
9855       {
9856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9857       };
9858     } catch (...) {
9859       {
9860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9861       };
9862     }
9863   }
9864
9865   jresult = result;
9866   return jresult;
9867 }
9868
9869
9870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9871   void * jresult ;
9872   Dali::Degree arg1 ;
9873   float arg2 ;
9874   float arg3 ;
9875   Dali::Degree *argp1 ;
9876   Dali::Degree result;
9877
9878   argp1 = (Dali::Degree *)jarg1;
9879   if (!argp1) {
9880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9881     return 0;
9882   }
9883   arg1 = *argp1;
9884   arg2 = (float)jarg2;
9885   arg3 = (float)jarg3;
9886   {
9887     try {
9888       result = Dali::Clamp(arg1,arg2,arg3);
9889     } catch (std::out_of_range& e) {
9890       {
9891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9892       };
9893     } catch (std::exception& e) {
9894       {
9895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9896       };
9897     } catch (Dali::DaliException e) {
9898       {
9899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9900       };
9901     } catch (...) {
9902       {
9903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9904       };
9905     }
9906   }
9907
9908   jresult = new Dali::Degree((const Dali::Degree &)result);
9909   return jresult;
9910 }
9911
9912
9913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9914   void * jresult ;
9915   Dali::Radian *result = 0 ;
9916
9917   {
9918     try {
9919       result = (Dali::Radian *)new Dali::Radian();
9920     } catch (std::out_of_range& e) {
9921       {
9922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9923       };
9924     } catch (std::exception& e) {
9925       {
9926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9927       };
9928     } catch (Dali::DaliException e) {
9929       {
9930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9931       };
9932     } catch (...) {
9933       {
9934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9935       };
9936     }
9937   }
9938
9939   jresult = (void *)result;
9940   return jresult;
9941 }
9942
9943
9944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9945   void * jresult ;
9946   float arg1 ;
9947   Dali::Radian *result = 0 ;
9948
9949   arg1 = (float)jarg1;
9950   {
9951     try {
9952       result = (Dali::Radian *)new Dali::Radian(arg1);
9953     } catch (std::out_of_range& e) {
9954       {
9955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9956       };
9957     } catch (std::exception& e) {
9958       {
9959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9960       };
9961     } catch (Dali::DaliException e) {
9962       {
9963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9964       };
9965     } catch (...) {
9966       {
9967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9968       };
9969     }
9970   }
9971
9972   jresult = (void *)result;
9973   return jresult;
9974 }
9975
9976
9977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
9978   void * jresult ;
9979   Dali::Degree arg1 ;
9980   Dali::Degree *argp1 ;
9981   Dali::Radian *result = 0 ;
9982
9983   argp1 = (Dali::Degree *)jarg1;
9984   if (!argp1) {
9985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9986     return 0;
9987   }
9988   arg1 = *argp1;
9989   {
9990     try {
9991       result = (Dali::Radian *)new Dali::Radian(arg1);
9992     } catch (std::out_of_range& e) {
9993       {
9994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9995       };
9996     } catch (std::exception& e) {
9997       {
9998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9999       };
10000     } catch (Dali::DaliException e) {
10001       {
10002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10003       };
10004     } catch (...) {
10005       {
10006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10007       };
10008     }
10009   }
10010
10011   jresult = (void *)result;
10012   return jresult;
10013 }
10014
10015
10016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10017   void * jresult ;
10018   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10019   float arg2 ;
10020   Dali::Radian *result = 0 ;
10021
10022   arg1 = (Dali::Radian *)jarg1;
10023   arg2 = (float)jarg2;
10024   {
10025     try {
10026       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10027     } catch (std::out_of_range& e) {
10028       {
10029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10030       };
10031     } catch (std::exception& e) {
10032       {
10033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10034       };
10035     } catch (Dali::DaliException e) {
10036       {
10037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10038       };
10039     } catch (...) {
10040       {
10041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10042       };
10043     }
10044   }
10045
10046   jresult = (void *)result;
10047   return jresult;
10048 }
10049
10050
10051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10052   void * jresult ;
10053   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10054   Dali::Degree arg2 ;
10055   Dali::Degree *argp2 ;
10056   Dali::Radian *result = 0 ;
10057
10058   arg1 = (Dali::Radian *)jarg1;
10059   argp2 = (Dali::Degree *)jarg2;
10060   if (!argp2) {
10061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10062     return 0;
10063   }
10064   arg2 = *argp2;
10065   {
10066     try {
10067       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10068     } catch (std::out_of_range& e) {
10069       {
10070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10071       };
10072     } catch (std::exception& e) {
10073       {
10074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10075       };
10076     } catch (Dali::DaliException e) {
10077       {
10078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10079       };
10080     } catch (...) {
10081       {
10082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10083       };
10084     }
10085   }
10086
10087   jresult = (void *)result;
10088   return jresult;
10089 }
10090
10091
10092 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10093   float jresult ;
10094   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10095   float result;
10096
10097   arg1 = (Dali::Radian *)jarg1;
10098   {
10099     try {
10100       result = (float)((Dali::Radian const *)arg1)->operator float();
10101     } catch (std::out_of_range& e) {
10102       {
10103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10104       };
10105     } catch (std::exception& e) {
10106       {
10107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10108       };
10109     } catch (Dali::DaliException e) {
10110       {
10111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10112       };
10113     } catch (...) {
10114       {
10115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10116       };
10117     }
10118   }
10119
10120   jresult = result;
10121   return jresult;
10122 }
10123
10124
10125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10126   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10127   float arg2 ;
10128
10129   arg1 = (Dali::Radian *)jarg1;
10130   arg2 = (float)jarg2;
10131   if (arg1) (arg1)->radian = arg2;
10132 }
10133
10134
10135 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10136   float jresult ;
10137   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10138   float result;
10139
10140   arg1 = (Dali::Radian *)jarg1;
10141   result = (float) ((arg1)->radian);
10142   jresult = result;
10143   return jresult;
10144 }
10145
10146
10147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10148   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10149
10150   arg1 = (Dali::Radian *)jarg1;
10151   {
10152     try {
10153       delete arg1;
10154     } catch (std::out_of_range& e) {
10155       {
10156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10157       };
10158     } catch (std::exception& e) {
10159       {
10160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10161       };
10162     } catch (Dali::DaliException e) {
10163       {
10164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10165       };
10166     } catch (...) {
10167       {
10168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10169       };
10170     }
10171   }
10172
10173 }
10174
10175
10176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10177   unsigned int jresult ;
10178   Dali::Radian arg1 ;
10179   Dali::Radian arg2 ;
10180   Dali::Radian *argp1 ;
10181   Dali::Radian *argp2 ;
10182   bool result;
10183
10184   argp1 = (Dali::Radian *)jarg1;
10185   if (!argp1) {
10186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10187     return 0;
10188   }
10189   arg1 = *argp1;
10190   argp2 = (Dali::Radian *)jarg2;
10191   if (!argp2) {
10192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10193     return 0;
10194   }
10195   arg2 = *argp2;
10196   {
10197     try {
10198       result = (bool)Dali::operator ==(arg1,arg2);
10199     } catch (std::out_of_range& e) {
10200       {
10201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10202       };
10203     } catch (std::exception& e) {
10204       {
10205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10206       };
10207     } catch (Dali::DaliException e) {
10208       {
10209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10210       };
10211     } catch (...) {
10212       {
10213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10214       };
10215     }
10216   }
10217
10218   jresult = result;
10219   return jresult;
10220 }
10221
10222
10223 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10224   unsigned int jresult ;
10225   Dali::Radian arg1 ;
10226   Dali::Radian arg2 ;
10227   Dali::Radian *argp1 ;
10228   Dali::Radian *argp2 ;
10229   bool result;
10230
10231   argp1 = (Dali::Radian *)jarg1;
10232   if (!argp1) {
10233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10234     return 0;
10235   }
10236   arg1 = *argp1;
10237   argp2 = (Dali::Radian *)jarg2;
10238   if (!argp2) {
10239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10240     return 0;
10241   }
10242   arg2 = *argp2;
10243   {
10244     try {
10245       result = (bool)Dali::operator !=(arg1,arg2);
10246     } catch (std::out_of_range& e) {
10247       {
10248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10249       };
10250     } catch (std::exception& e) {
10251       {
10252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10253       };
10254     } catch (Dali::DaliException e) {
10255       {
10256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10257       };
10258     } catch (...) {
10259       {
10260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10261       };
10262     }
10263   }
10264
10265   jresult = result;
10266   return jresult;
10267 }
10268
10269
10270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10271   unsigned int jresult ;
10272   Dali::Radian arg1 ;
10273   Dali::Degree arg2 ;
10274   Dali::Radian *argp1 ;
10275   Dali::Degree *argp2 ;
10276   bool result;
10277
10278   argp1 = (Dali::Radian *)jarg1;
10279   if (!argp1) {
10280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10281     return 0;
10282   }
10283   arg1 = *argp1;
10284   argp2 = (Dali::Degree *)jarg2;
10285   if (!argp2) {
10286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10287     return 0;
10288   }
10289   arg2 = *argp2;
10290   {
10291     try {
10292       result = (bool)Dali::operator ==(arg1,arg2);
10293     } catch (std::out_of_range& e) {
10294       {
10295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10296       };
10297     } catch (std::exception& e) {
10298       {
10299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10300       };
10301     } catch (Dali::DaliException e) {
10302       {
10303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10304       };
10305     } catch (...) {
10306       {
10307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10308       };
10309     }
10310   }
10311
10312   jresult = result;
10313   return jresult;
10314 }
10315
10316
10317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10318   unsigned int jresult ;
10319   Dali::Radian arg1 ;
10320   Dali::Degree arg2 ;
10321   Dali::Radian *argp1 ;
10322   Dali::Degree *argp2 ;
10323   bool result;
10324
10325   argp1 = (Dali::Radian *)jarg1;
10326   if (!argp1) {
10327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10328     return 0;
10329   }
10330   arg1 = *argp1;
10331   argp2 = (Dali::Degree *)jarg2;
10332   if (!argp2) {
10333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10334     return 0;
10335   }
10336   arg2 = *argp2;
10337   {
10338     try {
10339       result = (bool)Dali::operator !=(arg1,arg2);
10340     } catch (std::out_of_range& e) {
10341       {
10342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10343       };
10344     } catch (std::exception& e) {
10345       {
10346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10347       };
10348     } catch (Dali::DaliException e) {
10349       {
10350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10351       };
10352     } catch (...) {
10353       {
10354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10355       };
10356     }
10357   }
10358
10359   jresult = result;
10360   return jresult;
10361 }
10362
10363
10364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10365   unsigned int jresult ;
10366   Dali::Degree arg1 ;
10367   Dali::Radian arg2 ;
10368   Dali::Degree *argp1 ;
10369   Dali::Radian *argp2 ;
10370   bool result;
10371
10372   argp1 = (Dali::Degree *)jarg1;
10373   if (!argp1) {
10374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10375     return 0;
10376   }
10377   arg1 = *argp1;
10378   argp2 = (Dali::Radian *)jarg2;
10379   if (!argp2) {
10380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10381     return 0;
10382   }
10383   arg2 = *argp2;
10384   {
10385     try {
10386       result = (bool)Dali::operator ==(arg1,arg2);
10387     } catch (std::out_of_range& e) {
10388       {
10389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10390       };
10391     } catch (std::exception& e) {
10392       {
10393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10394       };
10395     } catch (Dali::DaliException e) {
10396       {
10397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10398       };
10399     } catch (...) {
10400       {
10401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10402       };
10403     }
10404   }
10405
10406   jresult = result;
10407   return jresult;
10408 }
10409
10410
10411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10412   unsigned int jresult ;
10413   Dali::Degree arg1 ;
10414   Dali::Radian arg2 ;
10415   Dali::Degree *argp1 ;
10416   Dali::Radian *argp2 ;
10417   bool result;
10418
10419   argp1 = (Dali::Degree *)jarg1;
10420   if (!argp1) {
10421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10422     return 0;
10423   }
10424   arg1 = *argp1;
10425   argp2 = (Dali::Radian *)jarg2;
10426   if (!argp2) {
10427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10428     return 0;
10429   }
10430   arg2 = *argp2;
10431   {
10432     try {
10433       result = (bool)Dali::operator !=(arg1,arg2);
10434     } catch (std::out_of_range& e) {
10435       {
10436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10437       };
10438     } catch (std::exception& e) {
10439       {
10440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10441       };
10442     } catch (Dali::DaliException e) {
10443       {
10444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10445       };
10446     } catch (...) {
10447       {
10448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10449       };
10450     }
10451   }
10452
10453   jresult = result;
10454   return jresult;
10455 }
10456
10457
10458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10459   unsigned int jresult ;
10460   Dali::Radian arg1 ;
10461   Dali::Radian arg2 ;
10462   Dali::Radian *argp1 ;
10463   Dali::Radian *argp2 ;
10464   bool result;
10465
10466   argp1 = (Dali::Radian *)jarg1;
10467   if (!argp1) {
10468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10469     return 0;
10470   }
10471   arg1 = *argp1;
10472   argp2 = (Dali::Radian *)jarg2;
10473   if (!argp2) {
10474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10475     return 0;
10476   }
10477   arg2 = *argp2;
10478   {
10479     try {
10480       result = (bool)Dali::operator >(arg1,arg2);
10481     } catch (std::out_of_range& e) {
10482       {
10483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10484       };
10485     } catch (std::exception& e) {
10486       {
10487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10488       };
10489     } catch (Dali::DaliException e) {
10490       {
10491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10492       };
10493     } catch (...) {
10494       {
10495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10496       };
10497     }
10498   }
10499
10500   jresult = result;
10501   return jresult;
10502 }
10503
10504
10505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10506   unsigned int jresult ;
10507   Dali::Radian arg1 ;
10508   Dali::Degree arg2 ;
10509   Dali::Radian *argp1 ;
10510   Dali::Degree *argp2 ;
10511   bool result;
10512
10513   argp1 = (Dali::Radian *)jarg1;
10514   if (!argp1) {
10515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10516     return 0;
10517   }
10518   arg1 = *argp1;
10519   argp2 = (Dali::Degree *)jarg2;
10520   if (!argp2) {
10521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10522     return 0;
10523   }
10524   arg2 = *argp2;
10525   {
10526     try {
10527       result = (bool)Dali::operator >(arg1,arg2);
10528     } catch (std::out_of_range& e) {
10529       {
10530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10531       };
10532     } catch (std::exception& e) {
10533       {
10534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10535       };
10536     } catch (Dali::DaliException e) {
10537       {
10538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10539       };
10540     } catch (...) {
10541       {
10542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10543       };
10544     }
10545   }
10546
10547   jresult = result;
10548   return jresult;
10549 }
10550
10551
10552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10553   unsigned int jresult ;
10554   Dali::Degree arg1 ;
10555   Dali::Radian arg2 ;
10556   Dali::Degree *argp1 ;
10557   Dali::Radian *argp2 ;
10558   bool result;
10559
10560   argp1 = (Dali::Degree *)jarg1;
10561   if (!argp1) {
10562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10563     return 0;
10564   }
10565   arg1 = *argp1;
10566   argp2 = (Dali::Radian *)jarg2;
10567   if (!argp2) {
10568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10569     return 0;
10570   }
10571   arg2 = *argp2;
10572   {
10573     try {
10574       result = (bool)Dali::operator >(arg1,arg2);
10575     } catch (std::out_of_range& e) {
10576       {
10577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10578       };
10579     } catch (std::exception& e) {
10580       {
10581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10582       };
10583     } catch (Dali::DaliException e) {
10584       {
10585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10586       };
10587     } catch (...) {
10588       {
10589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10590       };
10591     }
10592   }
10593
10594   jresult = result;
10595   return jresult;
10596 }
10597
10598
10599 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10600   unsigned int jresult ;
10601   Dali::Radian arg1 ;
10602   Dali::Radian arg2 ;
10603   Dali::Radian *argp1 ;
10604   Dali::Radian *argp2 ;
10605   bool result;
10606
10607   argp1 = (Dali::Radian *)jarg1;
10608   if (!argp1) {
10609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10610     return 0;
10611   }
10612   arg1 = *argp1;
10613   argp2 = (Dali::Radian *)jarg2;
10614   if (!argp2) {
10615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10616     return 0;
10617   }
10618   arg2 = *argp2;
10619   {
10620     try {
10621       result = (bool)Dali::operator <(arg1,arg2);
10622     } catch (std::out_of_range& e) {
10623       {
10624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10625       };
10626     } catch (std::exception& e) {
10627       {
10628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10629       };
10630     } catch (Dali::DaliException e) {
10631       {
10632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10633       };
10634     } catch (...) {
10635       {
10636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10637       };
10638     }
10639   }
10640
10641   jresult = result;
10642   return jresult;
10643 }
10644
10645
10646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10647   unsigned int jresult ;
10648   Dali::Radian arg1 ;
10649   Dali::Degree arg2 ;
10650   Dali::Radian *argp1 ;
10651   Dali::Degree *argp2 ;
10652   bool result;
10653
10654   argp1 = (Dali::Radian *)jarg1;
10655   if (!argp1) {
10656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10657     return 0;
10658   }
10659   arg1 = *argp1;
10660   argp2 = (Dali::Degree *)jarg2;
10661   if (!argp2) {
10662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10663     return 0;
10664   }
10665   arg2 = *argp2;
10666   {
10667     try {
10668       result = (bool)Dali::operator <(arg1,arg2);
10669     } catch (std::out_of_range& e) {
10670       {
10671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10672       };
10673     } catch (std::exception& e) {
10674       {
10675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10676       };
10677     } catch (Dali::DaliException e) {
10678       {
10679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10680       };
10681     } catch (...) {
10682       {
10683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10684       };
10685     }
10686   }
10687
10688   jresult = result;
10689   return jresult;
10690 }
10691
10692
10693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10694   unsigned int jresult ;
10695   Dali::Degree arg1 ;
10696   Dali::Radian arg2 ;
10697   Dali::Degree *argp1 ;
10698   Dali::Radian *argp2 ;
10699   bool result;
10700
10701   argp1 = (Dali::Degree *)jarg1;
10702   if (!argp1) {
10703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10704     return 0;
10705   }
10706   arg1 = *argp1;
10707   argp2 = (Dali::Radian *)jarg2;
10708   if (!argp2) {
10709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10710     return 0;
10711   }
10712   arg2 = *argp2;
10713   {
10714     try {
10715       result = (bool)Dali::operator <(arg1,arg2);
10716     } catch (std::out_of_range& e) {
10717       {
10718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10719       };
10720     } catch (std::exception& e) {
10721       {
10722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10723       };
10724     } catch (Dali::DaliException e) {
10725       {
10726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10727       };
10728     } catch (...) {
10729       {
10730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10731       };
10732     }
10733   }
10734
10735   jresult = result;
10736   return jresult;
10737 }
10738
10739
10740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10741   void * jresult ;
10742   Dali::Radian arg1 ;
10743   float arg2 ;
10744   Dali::Radian *argp1 ;
10745   Dali::Radian result;
10746
10747   argp1 = (Dali::Radian *)jarg1;
10748   if (!argp1) {
10749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10750     return 0;
10751   }
10752   arg1 = *argp1;
10753   arg2 = (float)jarg2;
10754   {
10755     try {
10756       result = Dali::operator *(arg1,arg2);
10757     } catch (std::out_of_range& e) {
10758       {
10759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10760       };
10761     } catch (std::exception& e) {
10762       {
10763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10764       };
10765     } catch (Dali::DaliException e) {
10766       {
10767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10768       };
10769     } catch (...) {
10770       {
10771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10772       };
10773     }
10774   }
10775
10776   jresult = new Dali::Radian((const Dali::Radian &)result);
10777   return jresult;
10778 }
10779
10780
10781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10782   void * jresult ;
10783   Dali::Radian arg1 ;
10784   Dali::Radian *argp1 ;
10785   Dali::Radian result;
10786
10787   argp1 = (Dali::Radian *)jarg1;
10788   if (!argp1) {
10789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10790     return 0;
10791   }
10792   arg1 = *argp1;
10793   {
10794     try {
10795       result = Dali::operator -(arg1);
10796     } catch (std::out_of_range& e) {
10797       {
10798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10799       };
10800     } catch (std::exception& e) {
10801       {
10802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10803       };
10804     } catch (Dali::DaliException e) {
10805       {
10806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10807       };
10808     } catch (...) {
10809       {
10810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10811       };
10812     }
10813   }
10814
10815   jresult = new Dali::Radian((const Dali::Radian &)result);
10816   return jresult;
10817 }
10818
10819
10820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10821   void * jresult ;
10822   Dali::Radian arg1 ;
10823   float arg2 ;
10824   float arg3 ;
10825   Dali::Radian *argp1 ;
10826   Dali::Radian result;
10827
10828   argp1 = (Dali::Radian *)jarg1;
10829   if (!argp1) {
10830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10831     return 0;
10832   }
10833   arg1 = *argp1;
10834   arg2 = (float)jarg2;
10835   arg3 = (float)jarg3;
10836   {
10837     try {
10838       result = Dali::Clamp(arg1,arg2,arg3);
10839     } catch (std::out_of_range& e) {
10840       {
10841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10842       };
10843     } catch (std::exception& e) {
10844       {
10845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10846       };
10847     } catch (Dali::DaliException e) {
10848       {
10849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10850       };
10851     } catch (...) {
10852       {
10853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10854       };
10855     }
10856   }
10857
10858   jresult = new Dali::Radian((const Dali::Radian &)result);
10859   return jresult;
10860 }
10861
10862
10863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10864   void * jresult ;
10865   Dali::Quaternion *result = 0 ;
10866
10867   {
10868     try {
10869       result = (Dali::Quaternion *)new Dali::Quaternion();
10870     } catch (std::out_of_range& e) {
10871       {
10872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10873       };
10874     } catch (std::exception& e) {
10875       {
10876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10877       };
10878     } catch (Dali::DaliException e) {
10879       {
10880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10881       };
10882     } catch (...) {
10883       {
10884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10885       };
10886     }
10887   }
10888
10889   jresult = (void *)result;
10890   return jresult;
10891 }
10892
10893
10894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10895   void * jresult ;
10896   Dali::Radian arg1 ;
10897   Dali::Vector3 *arg2 = 0 ;
10898   Dali::Radian *argp1 ;
10899   Dali::Quaternion *result = 0 ;
10900
10901   argp1 = (Dali::Radian *)jarg1;
10902   if (!argp1) {
10903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10904     return 0;
10905   }
10906   arg1 = *argp1;
10907   arg2 = (Dali::Vector3 *)jarg2;
10908   if (!arg2) {
10909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10910     return 0;
10911   }
10912   {
10913     try {
10914       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10915     } catch (std::out_of_range& e) {
10916       {
10917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10918       };
10919     } catch (std::exception& e) {
10920       {
10921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10922       };
10923     } catch (Dali::DaliException e) {
10924       {
10925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10926       };
10927     } catch (...) {
10928       {
10929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10930       };
10931     }
10932   }
10933
10934   jresult = (void *)result;
10935   return jresult;
10936 }
10937
10938
10939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10940   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10941
10942   arg1 = (Dali::Quaternion *)jarg1;
10943   {
10944     try {
10945       delete arg1;
10946     } catch (std::out_of_range& e) {
10947       {
10948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10949       };
10950     } catch (std::exception& e) {
10951       {
10952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10953       };
10954     } catch (Dali::DaliException e) {
10955       {
10956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10957       };
10958     } catch (...) {
10959       {
10960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10961       };
10962     }
10963   }
10964
10965 }
10966
10967
10968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10969   void * jresult ;
10970   Dali::Quaternion *result = 0 ;
10971
10972   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
10973   jresult = (void *)result;
10974   return jresult;
10975 }
10976
10977
10978 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
10979   unsigned int jresult ;
10980   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10981   bool result;
10982
10983   arg1 = (Dali::Quaternion *)jarg1;
10984   {
10985     try {
10986       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
10987     } catch (std::out_of_range& e) {
10988       {
10989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10990       };
10991     } catch (std::exception& e) {
10992       {
10993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10994       };
10995     } catch (Dali::DaliException e) {
10996       {
10997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10998       };
10999     } catch (...) {
11000       {
11001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11002       };
11003     }
11004   }
11005
11006   jresult = result;
11007   return jresult;
11008 }
11009
11010
11011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11012   unsigned int jresult ;
11013   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11014   Dali::Vector3 *arg2 = 0 ;
11015   Dali::Radian *arg3 = 0 ;
11016   bool result;
11017
11018   arg1 = (Dali::Quaternion *)jarg1;
11019   arg2 = (Dali::Vector3 *)jarg2;
11020   if (!arg2) {
11021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11022     return 0;
11023   }
11024   arg3 = (Dali::Radian *)jarg3;
11025   if (!arg3) {
11026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11027     return 0;
11028   }
11029   {
11030     try {
11031       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11032     } catch (std::out_of_range& e) {
11033       {
11034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11035       };
11036     } catch (std::exception& e) {
11037       {
11038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11039       };
11040     } catch (Dali::DaliException e) {
11041       {
11042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11043       };
11044     } catch (...) {
11045       {
11046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11047       };
11048     }
11049   }
11050
11051   jresult = result;
11052   return jresult;
11053 }
11054
11055
11056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11057   void * jresult ;
11058   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11059   Dali::Quaternion *arg2 = 0 ;
11060   Dali::Quaternion result;
11061
11062   arg1 = (Dali::Quaternion *)jarg1;
11063   arg2 = (Dali::Quaternion *)jarg2;
11064   if (!arg2) {
11065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11066     return 0;
11067   }
11068   {
11069     try {
11070       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11071     } catch (std::out_of_range& e) {
11072       {
11073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11074       };
11075     } catch (std::exception& e) {
11076       {
11077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11078       };
11079     } catch (Dali::DaliException e) {
11080       {
11081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11082       };
11083     } catch (...) {
11084       {
11085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11086       };
11087     }
11088   }
11089
11090   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11091   return jresult;
11092 }
11093
11094
11095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11096   void * jresult ;
11097   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11098   Dali::Quaternion *arg2 = 0 ;
11099   Dali::Quaternion result;
11100
11101   arg1 = (Dali::Quaternion *)jarg1;
11102   arg2 = (Dali::Quaternion *)jarg2;
11103   if (!arg2) {
11104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11105     return 0;
11106   }
11107   {
11108     try {
11109       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11110     } catch (std::out_of_range& e) {
11111       {
11112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11113       };
11114     } catch (std::exception& e) {
11115       {
11116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11117       };
11118     } catch (Dali::DaliException e) {
11119       {
11120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11121       };
11122     } catch (...) {
11123       {
11124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11125       };
11126     }
11127   }
11128
11129   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11130   return jresult;
11131 }
11132
11133
11134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11135   void * jresult ;
11136   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11137   Dali::Quaternion *arg2 = 0 ;
11138   Dali::Quaternion result;
11139
11140   arg1 = (Dali::Quaternion *)jarg1;
11141   arg2 = (Dali::Quaternion *)jarg2;
11142   if (!arg2) {
11143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11144     return 0;
11145   }
11146   {
11147     try {
11148       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11149     } catch (std::out_of_range& e) {
11150       {
11151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11152       };
11153     } catch (std::exception& e) {
11154       {
11155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11156       };
11157     } catch (Dali::DaliException e) {
11158       {
11159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11160       };
11161     } catch (...) {
11162       {
11163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11164       };
11165     }
11166   }
11167
11168   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11169   return jresult;
11170 }
11171
11172
11173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11174   void * jresult ;
11175   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11176   Dali::Vector3 *arg2 = 0 ;
11177   Dali::Vector3 result;
11178
11179   arg1 = (Dali::Quaternion *)jarg1;
11180   arg2 = (Dali::Vector3 *)jarg2;
11181   if (!arg2) {
11182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11183     return 0;
11184   }
11185   {
11186     try {
11187       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11188     } catch (std::out_of_range& e) {
11189       {
11190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11191       };
11192     } catch (std::exception& e) {
11193       {
11194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11195       };
11196     } catch (Dali::DaliException e) {
11197       {
11198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11199       };
11200     } catch (...) {
11201       {
11202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11203       };
11204     }
11205   }
11206
11207   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11208   return jresult;
11209 }
11210
11211
11212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11213   void * jresult ;
11214   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11215   Dali::Quaternion *arg2 = 0 ;
11216   Dali::Quaternion result;
11217
11218   arg1 = (Dali::Quaternion *)jarg1;
11219   arg2 = (Dali::Quaternion *)jarg2;
11220   if (!arg2) {
11221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11222     return 0;
11223   }
11224   {
11225     try {
11226       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11227     } catch (std::out_of_range& e) {
11228       {
11229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11230       };
11231     } catch (std::exception& e) {
11232       {
11233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11234       };
11235     } catch (Dali::DaliException e) {
11236       {
11237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11238       };
11239     } catch (...) {
11240       {
11241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11242       };
11243     }
11244   }
11245
11246   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11247   return jresult;
11248 }
11249
11250
11251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11252   void * jresult ;
11253   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11254   float arg2 ;
11255   Dali::Quaternion result;
11256
11257   arg1 = (Dali::Quaternion *)jarg1;
11258   arg2 = (float)jarg2;
11259   {
11260     try {
11261       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11262     } catch (std::out_of_range& e) {
11263       {
11264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11265       };
11266     } catch (std::exception& e) {
11267       {
11268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11269       };
11270     } catch (Dali::DaliException e) {
11271       {
11272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11273       };
11274     } catch (...) {
11275       {
11276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11277       };
11278     }
11279   }
11280
11281   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11282   return jresult;
11283 }
11284
11285
11286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11287   void * jresult ;
11288   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11289   float arg2 ;
11290   Dali::Quaternion result;
11291
11292   arg1 = (Dali::Quaternion *)jarg1;
11293   arg2 = (float)jarg2;
11294   {
11295     try {
11296       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11297     } catch (std::out_of_range& e) {
11298       {
11299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11300       };
11301     } catch (std::exception& e) {
11302       {
11303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11304       };
11305     } catch (Dali::DaliException e) {
11306       {
11307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11308       };
11309     } catch (...) {
11310       {
11311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11312       };
11313     }
11314   }
11315
11316   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11317   return jresult;
11318 }
11319
11320
11321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11322   void * jresult ;
11323   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11324   Dali::Quaternion result;
11325
11326   arg1 = (Dali::Quaternion *)jarg1;
11327   {
11328     try {
11329       result = ((Dali::Quaternion const *)arg1)->operator -();
11330     } catch (std::out_of_range& e) {
11331       {
11332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11333       };
11334     } catch (std::exception& e) {
11335       {
11336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11337       };
11338     } catch (Dali::DaliException e) {
11339       {
11340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11341       };
11342     } catch (...) {
11343       {
11344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11345       };
11346     }
11347   }
11348
11349   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11350   return jresult;
11351 }
11352
11353
11354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11355   void * jresult ;
11356   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11357   Dali::Quaternion *arg2 = 0 ;
11358   Dali::Quaternion *result = 0 ;
11359
11360   arg1 = (Dali::Quaternion *)jarg1;
11361   arg2 = (Dali::Quaternion *)jarg2;
11362   if (!arg2) {
11363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11364     return 0;
11365   }
11366   {
11367     try {
11368       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11369     } catch (std::out_of_range& e) {
11370       {
11371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11372       };
11373     } catch (std::exception& e) {
11374       {
11375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11376       };
11377     } catch (Dali::DaliException e) {
11378       {
11379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11380       };
11381     } catch (...) {
11382       {
11383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11384       };
11385     }
11386   }
11387
11388   jresult = (void *)result;
11389   return jresult;
11390 }
11391
11392
11393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11394   void * jresult ;
11395   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11396   Dali::Quaternion *arg2 = 0 ;
11397   Dali::Quaternion *result = 0 ;
11398
11399   arg1 = (Dali::Quaternion *)jarg1;
11400   arg2 = (Dali::Quaternion *)jarg2;
11401   if (!arg2) {
11402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11403     return 0;
11404   }
11405   {
11406     try {
11407       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11408     } catch (std::out_of_range& e) {
11409       {
11410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11411       };
11412     } catch (std::exception& e) {
11413       {
11414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11415       };
11416     } catch (Dali::DaliException e) {
11417       {
11418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11419       };
11420     } catch (...) {
11421       {
11422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11423       };
11424     }
11425   }
11426
11427   jresult = (void *)result;
11428   return jresult;
11429 }
11430
11431
11432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11433   void * jresult ;
11434   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11435   Dali::Quaternion *arg2 = 0 ;
11436   Dali::Quaternion *result = 0 ;
11437
11438   arg1 = (Dali::Quaternion *)jarg1;
11439   arg2 = (Dali::Quaternion *)jarg2;
11440   if (!arg2) {
11441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11442     return 0;
11443   }
11444   {
11445     try {
11446       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11447     } catch (std::out_of_range& e) {
11448       {
11449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11450       };
11451     } catch (std::exception& e) {
11452       {
11453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11454       };
11455     } catch (Dali::DaliException e) {
11456       {
11457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11458       };
11459     } catch (...) {
11460       {
11461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11462       };
11463     }
11464   }
11465
11466   jresult = (void *)result;
11467   return jresult;
11468 }
11469
11470
11471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11472   void * jresult ;
11473   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11474   float arg2 ;
11475   Dali::Quaternion *result = 0 ;
11476
11477   arg1 = (Dali::Quaternion *)jarg1;
11478   arg2 = (float)jarg2;
11479   {
11480     try {
11481       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11482     } catch (std::out_of_range& e) {
11483       {
11484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11485       };
11486     } catch (std::exception& e) {
11487       {
11488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11489       };
11490     } catch (Dali::DaliException e) {
11491       {
11492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11493       };
11494     } catch (...) {
11495       {
11496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11497       };
11498     }
11499   }
11500
11501   jresult = (void *)result;
11502   return jresult;
11503 }
11504
11505
11506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11507   void * jresult ;
11508   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11509   float arg2 ;
11510   Dali::Quaternion *result = 0 ;
11511
11512   arg1 = (Dali::Quaternion *)jarg1;
11513   arg2 = (float)jarg2;
11514   {
11515     try {
11516       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11517     } catch (std::out_of_range& e) {
11518       {
11519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11520       };
11521     } catch (std::exception& e) {
11522       {
11523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11524       };
11525     } catch (Dali::DaliException e) {
11526       {
11527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11528       };
11529     } catch (...) {
11530       {
11531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11532       };
11533     }
11534   }
11535
11536   jresult = (void *)result;
11537   return jresult;
11538 }
11539
11540
11541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11542   unsigned int jresult ;
11543   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11544   Dali::Quaternion *arg2 = 0 ;
11545   bool result;
11546
11547   arg1 = (Dali::Quaternion *)jarg1;
11548   arg2 = (Dali::Quaternion *)jarg2;
11549   if (!arg2) {
11550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11551     return 0;
11552   }
11553   {
11554     try {
11555       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11556     } catch (std::out_of_range& e) {
11557       {
11558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11559       };
11560     } catch (std::exception& e) {
11561       {
11562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11563       };
11564     } catch (Dali::DaliException e) {
11565       {
11566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11567       };
11568     } catch (...) {
11569       {
11570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11571       };
11572     }
11573   }
11574
11575   jresult = result;
11576   return jresult;
11577 }
11578
11579
11580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11581   unsigned int jresult ;
11582   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11583   Dali::Quaternion *arg2 = 0 ;
11584   bool result;
11585
11586   arg1 = (Dali::Quaternion *)jarg1;
11587   arg2 = (Dali::Quaternion *)jarg2;
11588   if (!arg2) {
11589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11590     return 0;
11591   }
11592   {
11593     try {
11594       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11595     } catch (std::out_of_range& e) {
11596       {
11597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11598       };
11599     } catch (std::exception& e) {
11600       {
11601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11602       };
11603     } catch (Dali::DaliException e) {
11604       {
11605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11606       };
11607     } catch (...) {
11608       {
11609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11610       };
11611     }
11612   }
11613
11614   jresult = result;
11615   return jresult;
11616 }
11617
11618
11619 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11620   float jresult ;
11621   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11622   float result;
11623
11624   arg1 = (Dali::Quaternion *)jarg1;
11625   {
11626     try {
11627       result = (float)((Dali::Quaternion const *)arg1)->Length();
11628     } catch (std::out_of_range& e) {
11629       {
11630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11631       };
11632     } catch (std::exception& e) {
11633       {
11634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11635       };
11636     } catch (Dali::DaliException e) {
11637       {
11638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11639       };
11640     } catch (...) {
11641       {
11642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11643       };
11644     }
11645   }
11646
11647   jresult = result;
11648   return jresult;
11649 }
11650
11651
11652 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11653   float jresult ;
11654   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11655   float result;
11656
11657   arg1 = (Dali::Quaternion *)jarg1;
11658   {
11659     try {
11660       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11661     } catch (std::out_of_range& e) {
11662       {
11663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11664       };
11665     } catch (std::exception& e) {
11666       {
11667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11668       };
11669     } catch (Dali::DaliException e) {
11670       {
11671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11672       };
11673     } catch (...) {
11674       {
11675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11676       };
11677     }
11678   }
11679
11680   jresult = result;
11681   return jresult;
11682 }
11683
11684
11685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11686   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11687
11688   arg1 = (Dali::Quaternion *)jarg1;
11689   {
11690     try {
11691       (arg1)->Normalize();
11692     } catch (std::out_of_range& e) {
11693       {
11694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11695       };
11696     } catch (std::exception& e) {
11697       {
11698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11699       };
11700     } catch (Dali::DaliException e) {
11701       {
11702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11703       };
11704     } catch (...) {
11705       {
11706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11707       };
11708     }
11709   }
11710
11711 }
11712
11713
11714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11715   void * jresult ;
11716   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11717   Dali::Quaternion result;
11718
11719   arg1 = (Dali::Quaternion *)jarg1;
11720   {
11721     try {
11722       result = ((Dali::Quaternion const *)arg1)->Normalized();
11723     } catch (std::out_of_range& e) {
11724       {
11725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11726       };
11727     } catch (std::exception& e) {
11728       {
11729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11730       };
11731     } catch (Dali::DaliException e) {
11732       {
11733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11734       };
11735     } catch (...) {
11736       {
11737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11738       };
11739     }
11740   }
11741
11742   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11743   return jresult;
11744 }
11745
11746
11747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11748   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11749
11750   arg1 = (Dali::Quaternion *)jarg1;
11751   {
11752     try {
11753       (arg1)->Conjugate();
11754     } catch (std::out_of_range& e) {
11755       {
11756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11757       };
11758     } catch (std::exception& e) {
11759       {
11760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11761       };
11762     } catch (Dali::DaliException e) {
11763       {
11764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11765       };
11766     } catch (...) {
11767       {
11768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11769       };
11770     }
11771   }
11772
11773 }
11774
11775
11776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11777   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11778
11779   arg1 = (Dali::Quaternion *)jarg1;
11780   {
11781     try {
11782       (arg1)->Invert();
11783     } catch (std::out_of_range& e) {
11784       {
11785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11786       };
11787     } catch (std::exception& e) {
11788       {
11789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11790       };
11791     } catch (Dali::DaliException e) {
11792       {
11793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11794       };
11795     } catch (...) {
11796       {
11797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11798       };
11799     }
11800   }
11801
11802 }
11803
11804
11805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11806   void * jresult ;
11807   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11808   Dali::Quaternion result;
11809
11810   arg1 = (Dali::Quaternion *)jarg1;
11811   {
11812     try {
11813       result = ((Dali::Quaternion const *)arg1)->Log();
11814     } catch (std::out_of_range& e) {
11815       {
11816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11817       };
11818     } catch (std::exception& e) {
11819       {
11820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11821       };
11822     } catch (Dali::DaliException e) {
11823       {
11824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11825       };
11826     } catch (...) {
11827       {
11828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11829       };
11830     }
11831   }
11832
11833   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11834   return jresult;
11835 }
11836
11837
11838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11839   void * jresult ;
11840   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11841   Dali::Quaternion result;
11842
11843   arg1 = (Dali::Quaternion *)jarg1;
11844   {
11845     try {
11846       result = ((Dali::Quaternion const *)arg1)->Exp();
11847     } catch (std::out_of_range& e) {
11848       {
11849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11850       };
11851     } catch (std::exception& e) {
11852       {
11853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11854       };
11855     } catch (Dali::DaliException e) {
11856       {
11857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11858       };
11859     } catch (...) {
11860       {
11861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11862       };
11863     }
11864   }
11865
11866   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11867   return jresult;
11868 }
11869
11870
11871 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11872   float jresult ;
11873   Dali::Quaternion *arg1 = 0 ;
11874   Dali::Quaternion *arg2 = 0 ;
11875   float result;
11876
11877   arg1 = (Dali::Quaternion *)jarg1;
11878   if (!arg1) {
11879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11880     return 0;
11881   }
11882   arg2 = (Dali::Quaternion *)jarg2;
11883   if (!arg2) {
11884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11885     return 0;
11886   }
11887   {
11888     try {
11889       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11890     } catch (std::out_of_range& e) {
11891       {
11892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11893       };
11894     } catch (std::exception& e) {
11895       {
11896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11897       };
11898     } catch (Dali::DaliException e) {
11899       {
11900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11901       };
11902     } catch (...) {
11903       {
11904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11905       };
11906     }
11907   }
11908
11909   jresult = result;
11910   return jresult;
11911 }
11912
11913
11914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11915   void * jresult ;
11916   Dali::Quaternion *arg1 = 0 ;
11917   Dali::Quaternion *arg2 = 0 ;
11918   float arg3 ;
11919   Dali::Quaternion result;
11920
11921   arg1 = (Dali::Quaternion *)jarg1;
11922   if (!arg1) {
11923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11924     return 0;
11925   }
11926   arg2 = (Dali::Quaternion *)jarg2;
11927   if (!arg2) {
11928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11929     return 0;
11930   }
11931   arg3 = (float)jarg3;
11932   {
11933     try {
11934       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11935     } catch (std::out_of_range& e) {
11936       {
11937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11938       };
11939     } catch (std::exception& e) {
11940       {
11941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11942       };
11943     } catch (Dali::DaliException e) {
11944       {
11945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11946       };
11947     } catch (...) {
11948       {
11949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11950       };
11951     }
11952   }
11953
11954   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11955   return jresult;
11956 }
11957
11958
11959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11960   void * jresult ;
11961   Dali::Quaternion *arg1 = 0 ;
11962   Dali::Quaternion *arg2 = 0 ;
11963   float arg3 ;
11964   Dali::Quaternion result;
11965
11966   arg1 = (Dali::Quaternion *)jarg1;
11967   if (!arg1) {
11968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11969     return 0;
11970   }
11971   arg2 = (Dali::Quaternion *)jarg2;
11972   if (!arg2) {
11973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11974     return 0;
11975   }
11976   arg3 = (float)jarg3;
11977   {
11978     try {
11979       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11980     } catch (std::out_of_range& e) {
11981       {
11982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11983       };
11984     } catch (std::exception& e) {
11985       {
11986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11987       };
11988     } catch (Dali::DaliException e) {
11989       {
11990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11991       };
11992     } catch (...) {
11993       {
11994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11995       };
11996     }
11997   }
11998
11999   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12000   return jresult;
12001 }
12002
12003
12004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12005   void * jresult ;
12006   Dali::Quaternion *arg1 = 0 ;
12007   Dali::Quaternion *arg2 = 0 ;
12008   float arg3 ;
12009   Dali::Quaternion result;
12010
12011   arg1 = (Dali::Quaternion *)jarg1;
12012   if (!arg1) {
12013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12014     return 0;
12015   }
12016   arg2 = (Dali::Quaternion *)jarg2;
12017   if (!arg2) {
12018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12019     return 0;
12020   }
12021   arg3 = (float)jarg3;
12022   {
12023     try {
12024       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12025     } catch (std::out_of_range& e) {
12026       {
12027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12028       };
12029     } catch (std::exception& e) {
12030       {
12031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12032       };
12033     } catch (Dali::DaliException e) {
12034       {
12035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12036       };
12037     } catch (...) {
12038       {
12039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12040       };
12041     }
12042   }
12043
12044   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12045   return jresult;
12046 }
12047
12048
12049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12050   void * jresult ;
12051   Dali::Quaternion *arg1 = 0 ;
12052   Dali::Quaternion *arg2 = 0 ;
12053   Dali::Quaternion *arg3 = 0 ;
12054   Dali::Quaternion *arg4 = 0 ;
12055   float arg5 ;
12056   Dali::Quaternion result;
12057
12058   arg1 = (Dali::Quaternion *)jarg1;
12059   if (!arg1) {
12060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12061     return 0;
12062   }
12063   arg2 = (Dali::Quaternion *)jarg2;
12064   if (!arg2) {
12065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12066     return 0;
12067   }
12068   arg3 = (Dali::Quaternion *)jarg3;
12069   if (!arg3) {
12070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12071     return 0;
12072   }
12073   arg4 = (Dali::Quaternion *)jarg4;
12074   if (!arg4) {
12075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12076     return 0;
12077   }
12078   arg5 = (float)jarg5;
12079   {
12080     try {
12081       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12082     } catch (std::out_of_range& e) {
12083       {
12084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12085       };
12086     } catch (std::exception& e) {
12087       {
12088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12089       };
12090     } catch (Dali::DaliException e) {
12091       {
12092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12093       };
12094     } catch (...) {
12095       {
12096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12097       };
12098     }
12099   }
12100
12101   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12102   return jresult;
12103 }
12104
12105
12106 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12107   float jresult ;
12108   Dali::Quaternion *arg1 = 0 ;
12109   Dali::Quaternion *arg2 = 0 ;
12110   float result;
12111
12112   arg1 = (Dali::Quaternion *)jarg1;
12113   if (!arg1) {
12114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12115     return 0;
12116   }
12117   arg2 = (Dali::Quaternion *)jarg2;
12118   if (!arg2) {
12119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12120     return 0;
12121   }
12122   {
12123     try {
12124       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12125     } catch (std::out_of_range& e) {
12126       {
12127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12128       };
12129     } catch (std::exception& e) {
12130       {
12131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12132       };
12133     } catch (Dali::DaliException e) {
12134       {
12135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12136       };
12137     } catch (...) {
12138       {
12139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12140       };
12141     }
12142   }
12143
12144   jresult = result;
12145   return jresult;
12146 }
12147
12148
12149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12150   void * jresult ;
12151   Dali::Matrix *result = 0 ;
12152
12153   {
12154     try {
12155       result = (Dali::Matrix *)new Dali::Matrix();
12156     } catch (std::out_of_range& e) {
12157       {
12158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12159       };
12160     } catch (std::exception& e) {
12161       {
12162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12163       };
12164     } catch (Dali::DaliException e) {
12165       {
12166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12167       };
12168     } catch (...) {
12169       {
12170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12171       };
12172     }
12173   }
12174
12175   jresult = (void *)result;
12176   return jresult;
12177 }
12178
12179
12180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12181   void * jresult ;
12182   bool arg1 ;
12183   Dali::Matrix *result = 0 ;
12184
12185   arg1 = jarg1 ? true : false;
12186   {
12187     try {
12188       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12189     } catch (std::out_of_range& e) {
12190       {
12191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12192       };
12193     } catch (std::exception& e) {
12194       {
12195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12196       };
12197     } catch (Dali::DaliException e) {
12198       {
12199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12200       };
12201     } catch (...) {
12202       {
12203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12204       };
12205     }
12206   }
12207
12208   jresult = (void *)result;
12209   return jresult;
12210 }
12211
12212
12213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12214   void * jresult ;
12215   float *arg1 = (float *) 0 ;
12216   Dali::Matrix *result = 0 ;
12217
12218   arg1 = jarg1;
12219   {
12220     try {
12221       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12222     } catch (std::out_of_range& e) {
12223       {
12224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12225       };
12226     } catch (std::exception& e) {
12227       {
12228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12229       };
12230     } catch (Dali::DaliException e) {
12231       {
12232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12233       };
12234     } catch (...) {
12235       {
12236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12237       };
12238     }
12239   }
12240
12241   jresult = (void *)result;
12242
12243
12244   return jresult;
12245 }
12246
12247
12248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12249   void * jresult ;
12250   Dali::Quaternion *arg1 = 0 ;
12251   Dali::Matrix *result = 0 ;
12252
12253   arg1 = (Dali::Quaternion *)jarg1;
12254   if (!arg1) {
12255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12256     return 0;
12257   }
12258   {
12259     try {
12260       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12261     } catch (std::out_of_range& e) {
12262       {
12263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12264       };
12265     } catch (std::exception& e) {
12266       {
12267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12268       };
12269     } catch (Dali::DaliException e) {
12270       {
12271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12272       };
12273     } catch (...) {
12274       {
12275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12276       };
12277     }
12278   }
12279
12280   jresult = (void *)result;
12281   return jresult;
12282 }
12283
12284
12285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12286   void * jresult ;
12287   Dali::Matrix *arg1 = 0 ;
12288   Dali::Matrix *result = 0 ;
12289
12290   arg1 = (Dali::Matrix *)jarg1;
12291   if (!arg1) {
12292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12293     return 0;
12294   }
12295   {
12296     try {
12297       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12298     } catch (std::out_of_range& e) {
12299       {
12300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12301       };
12302     } catch (std::exception& e) {
12303       {
12304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12305       };
12306     } catch (Dali::DaliException e) {
12307       {
12308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12309       };
12310     } catch (...) {
12311       {
12312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12313       };
12314     }
12315   }
12316
12317   jresult = (void *)result;
12318   return jresult;
12319 }
12320
12321
12322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12323   void * jresult ;
12324   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12325   Dali::Matrix *arg2 = 0 ;
12326   Dali::Matrix *result = 0 ;
12327
12328   arg1 = (Dali::Matrix *)jarg1;
12329   arg2 = (Dali::Matrix *)jarg2;
12330   if (!arg2) {
12331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12332     return 0;
12333   }
12334   {
12335     try {
12336       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12337     } catch (std::out_of_range& e) {
12338       {
12339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12340       };
12341     } catch (std::exception& e) {
12342       {
12343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12344       };
12345     } catch (Dali::DaliException e) {
12346       {
12347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12348       };
12349     } catch (...) {
12350       {
12351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12352       };
12353     }
12354   }
12355
12356   jresult = (void *)result;
12357   return jresult;
12358 }
12359
12360
12361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12362   void * jresult ;
12363   Dali::Matrix *result = 0 ;
12364
12365   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12366   jresult = (void *)result;
12367   return jresult;
12368 }
12369
12370
12371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12372   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12373
12374   arg1 = (Dali::Matrix *)jarg1;
12375   {
12376     try {
12377       (arg1)->SetIdentity();
12378     } catch (std::out_of_range& e) {
12379       {
12380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12381       };
12382     } catch (std::exception& e) {
12383       {
12384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12385       };
12386     } catch (Dali::DaliException e) {
12387       {
12388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12389       };
12390     } catch (...) {
12391       {
12392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12393       };
12394     }
12395   }
12396
12397 }
12398
12399
12400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12401   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12402   Dali::Vector3 *arg2 = 0 ;
12403
12404   arg1 = (Dali::Matrix *)jarg1;
12405   arg2 = (Dali::Vector3 *)jarg2;
12406   if (!arg2) {
12407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12408     return ;
12409   }
12410   {
12411     try {
12412       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12413     } catch (std::out_of_range& e) {
12414       {
12415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12416       };
12417     } catch (std::exception& e) {
12418       {
12419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12420       };
12421     } catch (Dali::DaliException e) {
12422       {
12423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12424       };
12425     } catch (...) {
12426       {
12427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12428       };
12429     }
12430   }
12431
12432 }
12433
12434
12435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12436   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12437   Dali::Matrix *arg2 = 0 ;
12438
12439   arg1 = (Dali::Matrix *)jarg1;
12440   arg2 = (Dali::Matrix *)jarg2;
12441   if (!arg2) {
12442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12443     return ;
12444   }
12445   {
12446     try {
12447       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12448     } catch (std::out_of_range& e) {
12449       {
12450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12451       };
12452     } catch (std::exception& e) {
12453       {
12454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12455       };
12456     } catch (Dali::DaliException e) {
12457       {
12458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12459       };
12460     } catch (...) {
12461       {
12462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12463       };
12464     }
12465   }
12466
12467 }
12468
12469
12470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12471   unsigned int jresult ;
12472   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12473   bool result;
12474
12475   arg1 = (Dali::Matrix *)jarg1;
12476   {
12477     try {
12478       result = (bool)(arg1)->Invert();
12479     } catch (std::out_of_range& e) {
12480       {
12481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12482       };
12483     } catch (std::exception& e) {
12484       {
12485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12486       };
12487     } catch (Dali::DaliException e) {
12488       {
12489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12490       };
12491     } catch (...) {
12492       {
12493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12494       };
12495     }
12496   }
12497
12498   jresult = result;
12499   return jresult;
12500 }
12501
12502
12503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12504   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12505
12506   arg1 = (Dali::Matrix *)jarg1;
12507   {
12508     try {
12509       (arg1)->Transpose();
12510     } catch (std::out_of_range& e) {
12511       {
12512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12513       };
12514     } catch (std::exception& e) {
12515       {
12516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12517       };
12518     } catch (Dali::DaliException e) {
12519       {
12520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12521       };
12522     } catch (...) {
12523       {
12524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12525       };
12526     }
12527   }
12528
12529 }
12530
12531
12532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12533   void * jresult ;
12534   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12535   Dali::Vector3 result;
12536
12537   arg1 = (Dali::Matrix *)jarg1;
12538   {
12539     try {
12540       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12541     } catch (std::out_of_range& e) {
12542       {
12543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12544       };
12545     } catch (std::exception& e) {
12546       {
12547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12548       };
12549     } catch (Dali::DaliException e) {
12550       {
12551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12552       };
12553     } catch (...) {
12554       {
12555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12556       };
12557     }
12558   }
12559
12560   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12561   return jresult;
12562 }
12563
12564
12565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12566   void * jresult ;
12567   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12568   Dali::Vector3 result;
12569
12570   arg1 = (Dali::Matrix *)jarg1;
12571   {
12572     try {
12573       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12574     } catch (std::out_of_range& e) {
12575       {
12576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12577       };
12578     } catch (std::exception& e) {
12579       {
12580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12581       };
12582     } catch (Dali::DaliException e) {
12583       {
12584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12585       };
12586     } catch (...) {
12587       {
12588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12589       };
12590     }
12591   }
12592
12593   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12594   return jresult;
12595 }
12596
12597
12598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12599   void * jresult ;
12600   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12601   Dali::Vector3 result;
12602
12603   arg1 = (Dali::Matrix *)jarg1;
12604   {
12605     try {
12606       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12607     } catch (std::out_of_range& e) {
12608       {
12609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12610       };
12611     } catch (std::exception& e) {
12612       {
12613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12614       };
12615     } catch (Dali::DaliException e) {
12616       {
12617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12618       };
12619     } catch (...) {
12620       {
12621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12622       };
12623     }
12624   }
12625
12626   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12627   return jresult;
12628 }
12629
12630
12631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12632   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12633   Dali::Vector3 *arg2 = 0 ;
12634
12635   arg1 = (Dali::Matrix *)jarg1;
12636   arg2 = (Dali::Vector3 *)jarg2;
12637   if (!arg2) {
12638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12639     return ;
12640   }
12641   {
12642     try {
12643       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12644     } catch (std::out_of_range& e) {
12645       {
12646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12647       };
12648     } catch (std::exception& e) {
12649       {
12650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12651       };
12652     } catch (Dali::DaliException e) {
12653       {
12654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12655       };
12656     } catch (...) {
12657       {
12658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12659       };
12660     }
12661   }
12662
12663 }
12664
12665
12666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12667   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12668   Dali::Vector3 *arg2 = 0 ;
12669
12670   arg1 = (Dali::Matrix *)jarg1;
12671   arg2 = (Dali::Vector3 *)jarg2;
12672   if (!arg2) {
12673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12674     return ;
12675   }
12676   {
12677     try {
12678       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12679     } catch (std::out_of_range& e) {
12680       {
12681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12682       };
12683     } catch (std::exception& e) {
12684       {
12685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12686       };
12687     } catch (Dali::DaliException e) {
12688       {
12689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12690       };
12691     } catch (...) {
12692       {
12693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12694       };
12695     }
12696   }
12697
12698 }
12699
12700
12701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12702   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12703   Dali::Vector3 *arg2 = 0 ;
12704
12705   arg1 = (Dali::Matrix *)jarg1;
12706   arg2 = (Dali::Vector3 *)jarg2;
12707   if (!arg2) {
12708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12709     return ;
12710   }
12711   {
12712     try {
12713       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12714     } catch (std::out_of_range& e) {
12715       {
12716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12717       };
12718     } catch (std::exception& e) {
12719       {
12720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12721       };
12722     } catch (Dali::DaliException e) {
12723       {
12724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12725       };
12726     } catch (...) {
12727       {
12728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12729       };
12730     }
12731   }
12732
12733 }
12734
12735
12736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12737   void * jresult ;
12738   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12739   Dali::Vector4 *result = 0 ;
12740
12741   arg1 = (Dali::Matrix *)jarg1;
12742   {
12743     try {
12744       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12745     } catch (std::out_of_range& e) {
12746       {
12747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12748       };
12749     } catch (std::exception& e) {
12750       {
12751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12752       };
12753     } catch (Dali::DaliException e) {
12754       {
12755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12756       };
12757     } catch (...) {
12758       {
12759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12760       };
12761     }
12762   }
12763
12764   jresult = (void *)result;
12765   return jresult;
12766 }
12767
12768
12769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12770   void * jresult ;
12771   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12772   Dali::Vector3 *result = 0 ;
12773
12774   arg1 = (Dali::Matrix *)jarg1;
12775   {
12776     try {
12777       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12778     } catch (std::out_of_range& e) {
12779       {
12780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12781       };
12782     } catch (std::exception& e) {
12783       {
12784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12785       };
12786     } catch (Dali::DaliException e) {
12787       {
12788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12789       };
12790     } catch (...) {
12791       {
12792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12793       };
12794     }
12795   }
12796
12797   jresult = (void *)result;
12798   return jresult;
12799 }
12800
12801
12802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12803   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12804   Dali::Vector4 *arg2 = 0 ;
12805
12806   arg1 = (Dali::Matrix *)jarg1;
12807   arg2 = (Dali::Vector4 *)jarg2;
12808   if (!arg2) {
12809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12810     return ;
12811   }
12812   {
12813     try {
12814       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12815     } catch (std::out_of_range& e) {
12816       {
12817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12818       };
12819     } catch (std::exception& e) {
12820       {
12821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12822       };
12823     } catch (Dali::DaliException e) {
12824       {
12825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12826       };
12827     } catch (...) {
12828       {
12829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12830       };
12831     }
12832   }
12833
12834 }
12835
12836
12837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12838   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12839   Dali::Vector3 *arg2 = 0 ;
12840
12841   arg1 = (Dali::Matrix *)jarg1;
12842   arg2 = (Dali::Vector3 *)jarg2;
12843   if (!arg2) {
12844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12845     return ;
12846   }
12847   {
12848     try {
12849       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12850     } catch (std::out_of_range& e) {
12851       {
12852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12853       };
12854     } catch (std::exception& e) {
12855       {
12856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12857       };
12858     } catch (Dali::DaliException e) {
12859       {
12860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12861       };
12862     } catch (...) {
12863       {
12864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12865       };
12866     }
12867   }
12868
12869 }
12870
12871
12872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12873   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12874
12875   arg1 = (Dali::Matrix *)jarg1;
12876   {
12877     try {
12878       (arg1)->OrthoNormalize();
12879     } catch (std::out_of_range& e) {
12880       {
12881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12882       };
12883     } catch (std::exception& e) {
12884       {
12885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12886       };
12887     } catch (Dali::DaliException e) {
12888       {
12889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12890       };
12891     } catch (...) {
12892       {
12893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12894       };
12895     }
12896   }
12897
12898 }
12899
12900
12901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12902   void * jresult ;
12903   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12904   float *result = 0 ;
12905
12906   arg1 = (Dali::Matrix *)jarg1;
12907   {
12908     try {
12909       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12910     } catch (std::out_of_range& e) {
12911       {
12912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12913       };
12914     } catch (std::exception& e) {
12915       {
12916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12917       };
12918     } catch (Dali::DaliException e) {
12919       {
12920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12921       };
12922     } catch (...) {
12923       {
12924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12925       };
12926     }
12927   }
12928
12929   jresult = (void *)result;
12930   return jresult;
12931 }
12932
12933
12934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12935   Dali::Matrix *arg1 = 0 ;
12936   Dali::Matrix *arg2 = 0 ;
12937   Dali::Matrix *arg3 = 0 ;
12938
12939   arg1 = (Dali::Matrix *)jarg1;
12940   if (!arg1) {
12941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12942     return ;
12943   }
12944   arg2 = (Dali::Matrix *)jarg2;
12945   if (!arg2) {
12946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12947     return ;
12948   }
12949   arg3 = (Dali::Matrix *)jarg3;
12950   if (!arg3) {
12951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12952     return ;
12953   }
12954   {
12955     try {
12956       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12957     } catch (std::out_of_range& e) {
12958       {
12959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12960       };
12961     } catch (std::exception& e) {
12962       {
12963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12964       };
12965     } catch (Dali::DaliException e) {
12966       {
12967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12968       };
12969     } catch (...) {
12970       {
12971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12972       };
12973     }
12974   }
12975
12976 }
12977
12978
12979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
12980   Dali::Matrix *arg1 = 0 ;
12981   Dali::Matrix *arg2 = 0 ;
12982   Dali::Quaternion *arg3 = 0 ;
12983
12984   arg1 = (Dali::Matrix *)jarg1;
12985   if (!arg1) {
12986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12987     return ;
12988   }
12989   arg2 = (Dali::Matrix *)jarg2;
12990   if (!arg2) {
12991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12992     return ;
12993   }
12994   arg3 = (Dali::Quaternion *)jarg3;
12995   if (!arg3) {
12996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12997     return ;
12998   }
12999   {
13000     try {
13001       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13002     } catch (std::out_of_range& e) {
13003       {
13004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13005       };
13006     } catch (std::exception& e) {
13007       {
13008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13009       };
13010     } catch (Dali::DaliException e) {
13011       {
13012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13013       };
13014     } catch (...) {
13015       {
13016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13017       };
13018     }
13019   }
13020
13021 }
13022
13023
13024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13025   void * jresult ;
13026   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13027   Dali::Vector4 *arg2 = 0 ;
13028   Dali::Vector4 result;
13029
13030   arg1 = (Dali::Matrix *)jarg1;
13031   arg2 = (Dali::Vector4 *)jarg2;
13032   if (!arg2) {
13033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13034     return 0;
13035   }
13036   {
13037     try {
13038       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13039     } catch (std::out_of_range& e) {
13040       {
13041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13042       };
13043     } catch (std::exception& e) {
13044       {
13045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13046       };
13047     } catch (Dali::DaliException e) {
13048       {
13049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13050       };
13051     } catch (...) {
13052       {
13053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13054       };
13055     }
13056   }
13057
13058   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13059   return jresult;
13060 }
13061
13062
13063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13064   unsigned int jresult ;
13065   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13066   Dali::Matrix *arg2 = 0 ;
13067   bool result;
13068
13069   arg1 = (Dali::Matrix *)jarg1;
13070   arg2 = (Dali::Matrix *)jarg2;
13071   if (!arg2) {
13072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13073     return 0;
13074   }
13075   {
13076     try {
13077       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13078     } catch (std::out_of_range& e) {
13079       {
13080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13081       };
13082     } catch (std::exception& e) {
13083       {
13084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13085       };
13086     } catch (Dali::DaliException e) {
13087       {
13088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13089       };
13090     } catch (...) {
13091       {
13092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13093       };
13094     }
13095   }
13096
13097   jresult = result;
13098   return jresult;
13099 }
13100
13101
13102 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13103   unsigned int jresult ;
13104   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13105   Dali::Matrix *arg2 = 0 ;
13106   bool result;
13107
13108   arg1 = (Dali::Matrix *)jarg1;
13109   arg2 = (Dali::Matrix *)jarg2;
13110   if (!arg2) {
13111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13112     return 0;
13113   }
13114   {
13115     try {
13116       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13117     } catch (std::out_of_range& e) {
13118       {
13119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13120       };
13121     } catch (std::exception& e) {
13122       {
13123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13124       };
13125     } catch (Dali::DaliException e) {
13126       {
13127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13128       };
13129     } catch (...) {
13130       {
13131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13132       };
13133     }
13134   }
13135
13136   jresult = result;
13137   return jresult;
13138 }
13139
13140
13141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13142   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13143   Dali::Vector3 *arg2 = 0 ;
13144   Dali::Quaternion *arg3 = 0 ;
13145   Dali::Vector3 *arg4 = 0 ;
13146
13147   arg1 = (Dali::Matrix *)jarg1;
13148   arg2 = (Dali::Vector3 *)jarg2;
13149   if (!arg2) {
13150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13151     return ;
13152   }
13153   arg3 = (Dali::Quaternion *)jarg3;
13154   if (!arg3) {
13155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13156     return ;
13157   }
13158   arg4 = (Dali::Vector3 *)jarg4;
13159   if (!arg4) {
13160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13161     return ;
13162   }
13163   {
13164     try {
13165       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13166     } catch (std::out_of_range& e) {
13167       {
13168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13169       };
13170     } catch (std::exception& e) {
13171       {
13172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13173       };
13174     } catch (Dali::DaliException e) {
13175       {
13176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13177       };
13178     } catch (...) {
13179       {
13180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13181       };
13182     }
13183   }
13184
13185 }
13186
13187
13188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13189   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13190   Dali::Vector3 *arg2 = 0 ;
13191   Dali::Quaternion *arg3 = 0 ;
13192   Dali::Vector3 *arg4 = 0 ;
13193
13194   arg1 = (Dali::Matrix *)jarg1;
13195   arg2 = (Dali::Vector3 *)jarg2;
13196   if (!arg2) {
13197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13198     return ;
13199   }
13200   arg3 = (Dali::Quaternion *)jarg3;
13201   if (!arg3) {
13202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13203     return ;
13204   }
13205   arg4 = (Dali::Vector3 *)jarg4;
13206   if (!arg4) {
13207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13208     return ;
13209   }
13210   {
13211     try {
13212       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13213     } catch (std::out_of_range& e) {
13214       {
13215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13216       };
13217     } catch (std::exception& e) {
13218       {
13219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13220       };
13221     } catch (Dali::DaliException e) {
13222       {
13223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13224       };
13225     } catch (...) {
13226       {
13227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13228       };
13229     }
13230   }
13231
13232 }
13233
13234
13235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13236   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13237   Dali::Vector3 *arg2 = 0 ;
13238   Dali::Vector3 *arg3 = 0 ;
13239   Dali::Vector3 *arg4 = 0 ;
13240   Dali::Vector3 *arg5 = 0 ;
13241
13242   arg1 = (Dali::Matrix *)jarg1;
13243   arg2 = (Dali::Vector3 *)jarg2;
13244   if (!arg2) {
13245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13246     return ;
13247   }
13248   arg3 = (Dali::Vector3 *)jarg3;
13249   if (!arg3) {
13250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13251     return ;
13252   }
13253   arg4 = (Dali::Vector3 *)jarg4;
13254   if (!arg4) {
13255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13256     return ;
13257   }
13258   arg5 = (Dali::Vector3 *)jarg5;
13259   if (!arg5) {
13260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13261     return ;
13262   }
13263   {
13264     try {
13265       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13266     } catch (std::out_of_range& e) {
13267       {
13268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13269       };
13270     } catch (std::exception& e) {
13271       {
13272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13273       };
13274     } catch (Dali::DaliException e) {
13275       {
13276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13277       };
13278     } catch (...) {
13279       {
13280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13281       };
13282     }
13283   }
13284
13285 }
13286
13287
13288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13289   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13290   Dali::Vector3 *arg2 = 0 ;
13291   Dali::Quaternion *arg3 = 0 ;
13292   Dali::Vector3 *arg4 = 0 ;
13293
13294   arg1 = (Dali::Matrix *)jarg1;
13295   arg2 = (Dali::Vector3 *)jarg2;
13296   if (!arg2) {
13297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13298     return ;
13299   }
13300   arg3 = (Dali::Quaternion *)jarg3;
13301   if (!arg3) {
13302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13303     return ;
13304   }
13305   arg4 = (Dali::Vector3 *)jarg4;
13306   if (!arg4) {
13307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13308     return ;
13309   }
13310   {
13311     try {
13312       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13313     } catch (std::out_of_range& e) {
13314       {
13315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13316       };
13317     } catch (std::exception& e) {
13318       {
13319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13320       };
13321     } catch (Dali::DaliException e) {
13322       {
13323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13324       };
13325     } catch (...) {
13326       {
13327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13328       };
13329     }
13330   }
13331
13332 }
13333
13334
13335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13336   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13337
13338   arg1 = (Dali::Matrix *)jarg1;
13339   {
13340     try {
13341       delete arg1;
13342     } catch (std::out_of_range& e) {
13343       {
13344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13345       };
13346     } catch (std::exception& e) {
13347       {
13348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13349       };
13350     } catch (Dali::DaliException e) {
13351       {
13352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13353       };
13354     } catch (...) {
13355       {
13356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13357       };
13358     }
13359   }
13360
13361 }
13362
13363
13364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13365   void * jresult ;
13366   Dali::Matrix3 *result = 0 ;
13367
13368   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13369   jresult = (void *)result;
13370   return jresult;
13371 }
13372
13373
13374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13375   void * jresult ;
13376   Dali::Matrix3 *result = 0 ;
13377
13378   {
13379     try {
13380       result = (Dali::Matrix3 *)new Dali::Matrix3();
13381     } catch (std::out_of_range& e) {
13382       {
13383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13384       };
13385     } catch (std::exception& e) {
13386       {
13387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13388       };
13389     } catch (Dali::DaliException e) {
13390       {
13391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13392       };
13393     } catch (...) {
13394       {
13395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13396       };
13397     }
13398   }
13399
13400   jresult = (void *)result;
13401   return jresult;
13402 }
13403
13404
13405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13406   void * jresult ;
13407   Dali::Matrix3 *arg1 = 0 ;
13408   Dali::Matrix3 *result = 0 ;
13409
13410   arg1 = (Dali::Matrix3 *)jarg1;
13411   if (!arg1) {
13412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13413     return 0;
13414   }
13415   {
13416     try {
13417       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13418     } catch (std::out_of_range& e) {
13419       {
13420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13421       };
13422     } catch (std::exception& e) {
13423       {
13424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13425       };
13426     } catch (Dali::DaliException e) {
13427       {
13428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13429       };
13430     } catch (...) {
13431       {
13432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13433       };
13434     }
13435   }
13436
13437   jresult = (void *)result;
13438   return jresult;
13439 }
13440
13441
13442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13443   void * jresult ;
13444   Dali::Matrix *arg1 = 0 ;
13445   Dali::Matrix3 *result = 0 ;
13446
13447   arg1 = (Dali::Matrix *)jarg1;
13448   if (!arg1) {
13449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13450     return 0;
13451   }
13452   {
13453     try {
13454       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13455     } catch (std::out_of_range& e) {
13456       {
13457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13458       };
13459     } catch (std::exception& e) {
13460       {
13461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13462       };
13463     } catch (Dali::DaliException e) {
13464       {
13465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13466       };
13467     } catch (...) {
13468       {
13469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13470       };
13471     }
13472   }
13473
13474   jresult = (void *)result;
13475   return jresult;
13476 }
13477
13478
13479 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) {
13480   void * jresult ;
13481   float arg1 ;
13482   float arg2 ;
13483   float arg3 ;
13484   float arg4 ;
13485   float arg5 ;
13486   float arg6 ;
13487   float arg7 ;
13488   float arg8 ;
13489   float arg9 ;
13490   Dali::Matrix3 *result = 0 ;
13491
13492   arg1 = (float)jarg1;
13493   arg2 = (float)jarg2;
13494   arg3 = (float)jarg3;
13495   arg4 = (float)jarg4;
13496   arg5 = (float)jarg5;
13497   arg6 = (float)jarg6;
13498   arg7 = (float)jarg7;
13499   arg8 = (float)jarg8;
13500   arg9 = (float)jarg9;
13501   {
13502     try {
13503       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13504     } catch (std::out_of_range& e) {
13505       {
13506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13507       };
13508     } catch (std::exception& e) {
13509       {
13510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13511       };
13512     } catch (Dali::DaliException e) {
13513       {
13514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13515       };
13516     } catch (...) {
13517       {
13518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13519       };
13520     }
13521   }
13522
13523   jresult = (void *)result;
13524   return jresult;
13525 }
13526
13527
13528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13529   void * jresult ;
13530   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13531   Dali::Matrix3 *arg2 = 0 ;
13532   Dali::Matrix3 *result = 0 ;
13533
13534   arg1 = (Dali::Matrix3 *)jarg1;
13535   arg2 = (Dali::Matrix3 *)jarg2;
13536   if (!arg2) {
13537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13538     return 0;
13539   }
13540   {
13541     try {
13542       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13543     } catch (std::out_of_range& e) {
13544       {
13545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13546       };
13547     } catch (std::exception& e) {
13548       {
13549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13550       };
13551     } catch (Dali::DaliException e) {
13552       {
13553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13554       };
13555     } catch (...) {
13556       {
13557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13558       };
13559     }
13560   }
13561
13562   jresult = (void *)result;
13563   return jresult;
13564 }
13565
13566
13567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13568   void * jresult ;
13569   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13570   Dali::Matrix *arg2 = 0 ;
13571   Dali::Matrix3 *result = 0 ;
13572
13573   arg1 = (Dali::Matrix3 *)jarg1;
13574   arg2 = (Dali::Matrix *)jarg2;
13575   if (!arg2) {
13576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13577     return 0;
13578   }
13579   {
13580     try {
13581       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13582     } catch (std::out_of_range& e) {
13583       {
13584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13585       };
13586     } catch (std::exception& e) {
13587       {
13588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13589       };
13590     } catch (Dali::DaliException e) {
13591       {
13592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13593       };
13594     } catch (...) {
13595       {
13596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13597       };
13598     }
13599   }
13600
13601   jresult = (void *)result;
13602   return jresult;
13603 }
13604
13605
13606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13607   unsigned int jresult ;
13608   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13609   Dali::Matrix3 *arg2 = 0 ;
13610   bool result;
13611
13612   arg1 = (Dali::Matrix3 *)jarg1;
13613   arg2 = (Dali::Matrix3 *)jarg2;
13614   if (!arg2) {
13615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13616     return 0;
13617   }
13618   {
13619     try {
13620       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13621     } catch (std::out_of_range& e) {
13622       {
13623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13624       };
13625     } catch (std::exception& e) {
13626       {
13627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13628       };
13629     } catch (Dali::DaliException e) {
13630       {
13631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13632       };
13633     } catch (...) {
13634       {
13635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13636       };
13637     }
13638   }
13639
13640   jresult = result;
13641   return jresult;
13642 }
13643
13644
13645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13646   unsigned int jresult ;
13647   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13648   Dali::Matrix3 *arg2 = 0 ;
13649   bool result;
13650
13651   arg1 = (Dali::Matrix3 *)jarg1;
13652   arg2 = (Dali::Matrix3 *)jarg2;
13653   if (!arg2) {
13654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13655     return 0;
13656   }
13657   {
13658     try {
13659       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13660     } catch (std::out_of_range& e) {
13661       {
13662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13663       };
13664     } catch (std::exception& e) {
13665       {
13666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13667       };
13668     } catch (Dali::DaliException e) {
13669       {
13670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13671       };
13672     } catch (...) {
13673       {
13674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13675       };
13676     }
13677   }
13678
13679   jresult = result;
13680   return jresult;
13681 }
13682
13683
13684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13685   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13686
13687   arg1 = (Dali::Matrix3 *)jarg1;
13688   {
13689     try {
13690       delete arg1;
13691     } catch (std::out_of_range& e) {
13692       {
13693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13694       };
13695     } catch (std::exception& e) {
13696       {
13697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13698       };
13699     } catch (Dali::DaliException e) {
13700       {
13701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13702       };
13703     } catch (...) {
13704       {
13705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13706       };
13707     }
13708   }
13709
13710 }
13711
13712
13713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13714   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13715
13716   arg1 = (Dali::Matrix3 *)jarg1;
13717   {
13718     try {
13719       (arg1)->SetIdentity();
13720     } catch (std::out_of_range& e) {
13721       {
13722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13723       };
13724     } catch (std::exception& e) {
13725       {
13726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13727       };
13728     } catch (Dali::DaliException e) {
13729       {
13730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13731       };
13732     } catch (...) {
13733       {
13734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13735       };
13736     }
13737   }
13738
13739 }
13740
13741
13742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13743   void * jresult ;
13744   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13745   float *result = 0 ;
13746
13747   arg1 = (Dali::Matrix3 *)jarg1;
13748   {
13749     try {
13750       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13751     } catch (std::out_of_range& e) {
13752       {
13753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13754       };
13755     } catch (std::exception& e) {
13756       {
13757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13758       };
13759     } catch (Dali::DaliException e) {
13760       {
13761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13762       };
13763     } catch (...) {
13764       {
13765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13766       };
13767     }
13768   }
13769
13770   jresult = (void *)result;
13771   return jresult;
13772 }
13773
13774
13775 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13776   unsigned int jresult ;
13777   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13778   bool result;
13779
13780   arg1 = (Dali::Matrix3 *)jarg1;
13781   {
13782     try {
13783       result = (bool)(arg1)->Invert();
13784     } catch (std::out_of_range& e) {
13785       {
13786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13787       };
13788     } catch (std::exception& e) {
13789       {
13790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13791       };
13792     } catch (Dali::DaliException e) {
13793       {
13794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13795       };
13796     } catch (...) {
13797       {
13798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13799       };
13800     }
13801   }
13802
13803   jresult = result;
13804   return jresult;
13805 }
13806
13807
13808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13809   unsigned int jresult ;
13810   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13811   bool result;
13812
13813   arg1 = (Dali::Matrix3 *)jarg1;
13814   {
13815     try {
13816       result = (bool)(arg1)->Transpose();
13817     } catch (std::out_of_range& e) {
13818       {
13819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13820       };
13821     } catch (std::exception& e) {
13822       {
13823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13824       };
13825     } catch (Dali::DaliException e) {
13826       {
13827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13828       };
13829     } catch (...) {
13830       {
13831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13832       };
13833     }
13834   }
13835
13836   jresult = result;
13837   return jresult;
13838 }
13839
13840
13841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13842   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13843   float arg2 ;
13844
13845   arg1 = (Dali::Matrix3 *)jarg1;
13846   arg2 = (float)jarg2;
13847   {
13848     try {
13849       (arg1)->Scale(arg2);
13850     } catch (std::out_of_range& e) {
13851       {
13852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13853       };
13854     } catch (std::exception& e) {
13855       {
13856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13857       };
13858     } catch (Dali::DaliException e) {
13859       {
13860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13861       };
13862     } catch (...) {
13863       {
13864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13865       };
13866     }
13867   }
13868
13869 }
13870
13871
13872 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13873   float jresult ;
13874   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13875   float result;
13876
13877   arg1 = (Dali::Matrix3 *)jarg1;
13878   {
13879     try {
13880       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13881     } catch (std::out_of_range& e) {
13882       {
13883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13884       };
13885     } catch (std::exception& e) {
13886       {
13887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13888       };
13889     } catch (Dali::DaliException e) {
13890       {
13891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13892       };
13893     } catch (...) {
13894       {
13895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13896       };
13897     }
13898   }
13899
13900   jresult = result;
13901   return jresult;
13902 }
13903
13904
13905 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13906   unsigned int jresult ;
13907   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13908   bool result;
13909
13910   arg1 = (Dali::Matrix3 *)jarg1;
13911   {
13912     try {
13913       result = (bool)(arg1)->ScaledInverseTranspose();
13914     } catch (std::out_of_range& e) {
13915       {
13916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13917       };
13918     } catch (std::exception& e) {
13919       {
13920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13921       };
13922     } catch (Dali::DaliException e) {
13923       {
13924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13925       };
13926     } catch (...) {
13927       {
13928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13929       };
13930     }
13931   }
13932
13933   jresult = result;
13934   return jresult;
13935 }
13936
13937
13938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13939   Dali::Matrix3 *arg1 = 0 ;
13940   Dali::Matrix3 *arg2 = 0 ;
13941   Dali::Matrix3 *arg3 = 0 ;
13942
13943   arg1 = (Dali::Matrix3 *)jarg1;
13944   if (!arg1) {
13945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13946     return ;
13947   }
13948   arg2 = (Dali::Matrix3 *)jarg2;
13949   if (!arg2) {
13950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13951     return ;
13952   }
13953   arg3 = (Dali::Matrix3 *)jarg3;
13954   if (!arg3) {
13955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13956     return ;
13957   }
13958   {
13959     try {
13960       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13961     } catch (std::out_of_range& e) {
13962       {
13963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13964       };
13965     } catch (std::exception& e) {
13966       {
13967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13968       };
13969     } catch (Dali::DaliException e) {
13970       {
13971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13972       };
13973     } catch (...) {
13974       {
13975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13976       };
13977     }
13978   }
13979
13980 }
13981
13982
13983 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
13984   float jresult ;
13985   float arg1 ;
13986   float arg2 ;
13987   float result;
13988
13989   arg1 = (float)jarg1;
13990   arg2 = (float)jarg2;
13991   {
13992     try {
13993       result = (float)Dali::Random::Range(arg1,arg2);
13994     } catch (std::out_of_range& e) {
13995       {
13996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13997       };
13998     } catch (std::exception& e) {
13999       {
14000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14001       };
14002     } catch (Dali::DaliException e) {
14003       {
14004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14005       };
14006     } catch (...) {
14007       {
14008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14009       };
14010     }
14011   }
14012
14013   jresult = result;
14014   return jresult;
14015 }
14016
14017
14018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14019   void * jresult ;
14020   Dali::Vector4 result;
14021
14022   {
14023     try {
14024       result = Dali::Random::Axis();
14025     } catch (std::out_of_range& e) {
14026       {
14027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14028       };
14029     } catch (std::exception& e) {
14030       {
14031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14032       };
14033     } catch (Dali::DaliException e) {
14034       {
14035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14036       };
14037     } catch (...) {
14038       {
14039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14040       };
14041     }
14042   }
14043
14044   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14045   return jresult;
14046 }
14047
14048
14049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14050   void * jresult ;
14051   Dali::AngleAxis *result = 0 ;
14052
14053   {
14054     try {
14055       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14056     } catch (std::out_of_range& e) {
14057       {
14058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14059       };
14060     } catch (std::exception& e) {
14061       {
14062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14063       };
14064     } catch (Dali::DaliException e) {
14065       {
14066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14067       };
14068     } catch (...) {
14069       {
14070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14071       };
14072     }
14073   }
14074
14075   jresult = (void *)result;
14076   return jresult;
14077 }
14078
14079
14080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14081   void * jresult ;
14082   Dali::Radian arg1 ;
14083   Dali::Vector3 *arg2 = 0 ;
14084   Dali::Radian *argp1 ;
14085   Dali::AngleAxis *result = 0 ;
14086
14087   argp1 = (Dali::Radian *)jarg1;
14088   if (!argp1) {
14089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14090     return 0;
14091   }
14092   arg1 = *argp1;
14093   arg2 = (Dali::Vector3 *)jarg2;
14094   if (!arg2) {
14095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14096     return 0;
14097   }
14098   {
14099     try {
14100       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14101     } catch (std::out_of_range& e) {
14102       {
14103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14104       };
14105     } catch (std::exception& e) {
14106       {
14107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14108       };
14109     } catch (Dali::DaliException e) {
14110       {
14111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14112       };
14113     } catch (...) {
14114       {
14115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14116       };
14117     }
14118   }
14119
14120   jresult = (void *)result;
14121   return jresult;
14122 }
14123
14124
14125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14126   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14127   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14128
14129   arg1 = (Dali::AngleAxis *)jarg1;
14130   arg2 = (Dali::Radian *)jarg2;
14131   if (arg1) (arg1)->angle = *arg2;
14132 }
14133
14134
14135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14136   void * jresult ;
14137   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14138   Dali::Radian *result = 0 ;
14139
14140   arg1 = (Dali::AngleAxis *)jarg1;
14141   result = (Dali::Radian *)& ((arg1)->angle);
14142   jresult = (void *)result;
14143   return jresult;
14144 }
14145
14146
14147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14148   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14149   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14150
14151   arg1 = (Dali::AngleAxis *)jarg1;
14152   arg2 = (Dali::Vector3 *)jarg2;
14153   if (arg1) (arg1)->axis = *arg2;
14154 }
14155
14156
14157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14158   void * jresult ;
14159   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14160   Dali::Vector3 *result = 0 ;
14161
14162   arg1 = (Dali::AngleAxis *)jarg1;
14163   result = (Dali::Vector3 *)& ((arg1)->axis);
14164   jresult = (void *)result;
14165   return jresult;
14166 }
14167
14168
14169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14170   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14171
14172   arg1 = (Dali::AngleAxis *)jarg1;
14173   {
14174     try {
14175       delete arg1;
14176     } catch (std::out_of_range& e) {
14177       {
14178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14179       };
14180     } catch (std::exception& e) {
14181       {
14182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14183       };
14184     } catch (Dali::DaliException e) {
14185       {
14186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14187       };
14188     } catch (...) {
14189       {
14190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14191       };
14192     }
14193   }
14194
14195 }
14196
14197
14198 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14199   unsigned int jresult ;
14200   Dali::AngleAxis *arg1 = 0 ;
14201   Dali::AngleAxis *arg2 = 0 ;
14202   bool result;
14203
14204   arg1 = (Dali::AngleAxis *)jarg1;
14205   if (!arg1) {
14206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14207     return 0;
14208   }
14209   arg2 = (Dali::AngleAxis *)jarg2;
14210   if (!arg2) {
14211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14212     return 0;
14213   }
14214   {
14215     try {
14216       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14217     } catch (std::out_of_range& e) {
14218       {
14219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14220       };
14221     } catch (std::exception& e) {
14222       {
14223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14224       };
14225     } catch (Dali::DaliException e) {
14226       {
14227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14228       };
14229     } catch (...) {
14230       {
14231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14232       };
14233     }
14234   }
14235
14236   jresult = result;
14237   return jresult;
14238 }
14239
14240
14241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14242   unsigned int jresult ;
14243   unsigned int arg1 ;
14244   unsigned int result;
14245
14246   arg1 = (unsigned int)jarg1;
14247   {
14248     try {
14249       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14250     } catch (std::out_of_range& e) {
14251       {
14252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14253       };
14254     } catch (std::exception& e) {
14255       {
14256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14257       };
14258     } catch (Dali::DaliException e) {
14259       {
14260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14261       };
14262     } catch (...) {
14263       {
14264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14265       };
14266     }
14267   }
14268
14269   jresult = result;
14270   return jresult;
14271 }
14272
14273
14274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14275   unsigned int jresult ;
14276   unsigned int arg1 ;
14277   bool result;
14278
14279   arg1 = (unsigned int)jarg1;
14280   {
14281     try {
14282       result = (bool)Dali::IsPowerOfTwo(arg1);
14283     } catch (std::out_of_range& e) {
14284       {
14285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14286       };
14287     } catch (std::exception& e) {
14288       {
14289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14290       };
14291     } catch (Dali::DaliException e) {
14292       {
14293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14294       };
14295     } catch (...) {
14296       {
14297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14298       };
14299     }
14300   }
14301
14302   jresult = result;
14303   return jresult;
14304 }
14305
14306
14307 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14308   float jresult ;
14309   float arg1 ;
14310   float arg2 ;
14311   float result;
14312
14313   arg1 = (float)jarg1;
14314   arg2 = (float)jarg2;
14315   {
14316     try {
14317       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14318     } catch (std::out_of_range& e) {
14319       {
14320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14321       };
14322     } catch (std::exception& e) {
14323       {
14324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14325       };
14326     } catch (Dali::DaliException e) {
14327       {
14328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14329       };
14330     } catch (...) {
14331       {
14332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14333       };
14334     }
14335   }
14336
14337   jresult = result;
14338   return jresult;
14339 }
14340
14341
14342 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14343   unsigned int jresult ;
14344   float arg1 ;
14345   bool result;
14346
14347   arg1 = (float)jarg1;
14348   {
14349     try {
14350       result = (bool)Dali::EqualsZero(arg1);
14351     } catch (std::out_of_range& e) {
14352       {
14353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14354       };
14355     } catch (std::exception& e) {
14356       {
14357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14358       };
14359     } catch (Dali::DaliException e) {
14360       {
14361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14362       };
14363     } catch (...) {
14364       {
14365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14366       };
14367     }
14368   }
14369
14370   jresult = result;
14371   return jresult;
14372 }
14373
14374
14375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14376   unsigned int jresult ;
14377   float arg1 ;
14378   float arg2 ;
14379   bool result;
14380
14381   arg1 = (float)jarg1;
14382   arg2 = (float)jarg2;
14383   {
14384     try {
14385       result = (bool)Dali::Equals(arg1,arg2);
14386     } catch (std::out_of_range& e) {
14387       {
14388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14389       };
14390     } catch (std::exception& e) {
14391       {
14392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14393       };
14394     } catch (Dali::DaliException e) {
14395       {
14396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14397       };
14398     } catch (...) {
14399       {
14400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14401       };
14402     }
14403   }
14404
14405   jresult = result;
14406   return jresult;
14407 }
14408
14409
14410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14411   unsigned int jresult ;
14412   float arg1 ;
14413   float arg2 ;
14414   float arg3 ;
14415   bool result;
14416
14417   arg1 = (float)jarg1;
14418   arg2 = (float)jarg2;
14419   arg3 = (float)jarg3;
14420   {
14421     try {
14422       result = (bool)Dali::Equals(arg1,arg2,arg3);
14423     } catch (std::out_of_range& e) {
14424       {
14425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14426       };
14427     } catch (std::exception& e) {
14428       {
14429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14430       };
14431     } catch (Dali::DaliException e) {
14432       {
14433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14434       };
14435     } catch (...) {
14436       {
14437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14438       };
14439     }
14440   }
14441
14442   jresult = result;
14443   return jresult;
14444 }
14445
14446
14447 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14448   float jresult ;
14449   float arg1 ;
14450   int arg2 ;
14451   float result;
14452
14453   arg1 = (float)jarg1;
14454   arg2 = (int)jarg2;
14455   {
14456     try {
14457       result = (float)Dali::Round(arg1,arg2);
14458     } catch (std::out_of_range& e) {
14459       {
14460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14461       };
14462     } catch (std::exception& e) {
14463       {
14464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14465       };
14466     } catch (Dali::DaliException e) {
14467       {
14468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14469       };
14470     } catch (...) {
14471       {
14472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14473       };
14474     }
14475   }
14476
14477   jresult = result;
14478   return jresult;
14479 }
14480
14481
14482 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14483   float jresult ;
14484   float arg1 ;
14485   float arg2 ;
14486   float arg3 ;
14487   float result;
14488
14489   arg1 = (float)jarg1;
14490   arg2 = (float)jarg2;
14491   arg3 = (float)jarg3;
14492   {
14493     try {
14494       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14495     } catch (std::out_of_range& e) {
14496       {
14497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14498       };
14499     } catch (std::exception& e) {
14500       {
14501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14502       };
14503     } catch (Dali::DaliException e) {
14504       {
14505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14506       };
14507     } catch (...) {
14508       {
14509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14510       };
14511     }
14512   }
14513
14514   jresult = result;
14515   return jresult;
14516 }
14517
14518
14519 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14520   float jresult ;
14521   float arg1 ;
14522   float arg2 ;
14523   float arg3 ;
14524   float arg4 ;
14525   float result;
14526
14527   arg1 = (float)jarg1;
14528   arg2 = (float)jarg2;
14529   arg3 = (float)jarg3;
14530   arg4 = (float)jarg4;
14531   {
14532     try {
14533       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14534     } catch (std::out_of_range& e) {
14535       {
14536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14537       };
14538     } catch (std::exception& e) {
14539       {
14540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14541       };
14542     } catch (Dali::DaliException e) {
14543       {
14544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14545       };
14546     } catch (...) {
14547       {
14548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14549       };
14550     }
14551   }
14552
14553   jresult = result;
14554   return jresult;
14555 }
14556
14557
14558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14559   int jresult ;
14560   int result;
14561
14562   result = (int)(int)Dali::Property::INVALID_INDEX;
14563   jresult = result;
14564   return jresult;
14565 }
14566
14567
14568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14569   int jresult ;
14570   int result;
14571
14572   result = (int)(int)Dali::Property::INVALID_KEY;
14573   jresult = result;
14574   return jresult;
14575 }
14576
14577
14578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14579   int jresult ;
14580   int result;
14581
14582   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14583   jresult = result;
14584   return jresult;
14585 }
14586
14587
14588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14589   void * jresult ;
14590   Dali::Handle *arg1 = 0 ;
14591   Dali::Property::Index arg2 ;
14592   Dali::Property *result = 0 ;
14593
14594   arg1 = (Dali::Handle *)jarg1;
14595   if (!arg1) {
14596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14597     return 0;
14598   }
14599   arg2 = (Dali::Property::Index)jarg2;
14600   {
14601     try {
14602       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14603     } catch (std::out_of_range& e) {
14604       {
14605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14606       };
14607     } catch (std::exception& e) {
14608       {
14609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14610       };
14611     } catch (Dali::DaliException e) {
14612       {
14613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14614       };
14615     } catch (...) {
14616       {
14617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14618       };
14619     }
14620   }
14621
14622   jresult = (void *)result;
14623   return jresult;
14624 }
14625
14626
14627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14628   void * jresult ;
14629   Dali::Handle *arg1 = 0 ;
14630   Dali::Property::Index arg2 ;
14631   int arg3 ;
14632   Dali::Property *result = 0 ;
14633
14634   arg1 = (Dali::Handle *)jarg1;
14635   if (!arg1) {
14636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14637     return 0;
14638   }
14639   arg2 = (Dali::Property::Index)jarg2;
14640   arg3 = (int)jarg3;
14641   {
14642     try {
14643       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14644     } catch (std::out_of_range& e) {
14645       {
14646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14647       };
14648     } catch (std::exception& e) {
14649       {
14650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14651       };
14652     } catch (Dali::DaliException e) {
14653       {
14654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14655       };
14656     } catch (...) {
14657       {
14658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14659       };
14660     }
14661   }
14662
14663   jresult = (void *)result;
14664   return jresult;
14665 }
14666
14667
14668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14669   void * jresult ;
14670   Dali::Handle *arg1 = 0 ;
14671   std::string *arg2 = 0 ;
14672   Dali::Property *result = 0 ;
14673
14674   arg1 = (Dali::Handle *)jarg1;
14675   if (!arg1) {
14676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14677     return 0;
14678   }
14679   if (!jarg2) {
14680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14681     return 0;
14682   }
14683   std::string arg2_str(jarg2);
14684   arg2 = &arg2_str;
14685   {
14686     try {
14687       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14688     } catch (std::out_of_range& e) {
14689       {
14690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14691       };
14692     } catch (std::exception& e) {
14693       {
14694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14695       };
14696     } catch (Dali::DaliException e) {
14697       {
14698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14699       };
14700     } catch (...) {
14701       {
14702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14703       };
14704     }
14705   }
14706
14707   jresult = (void *)result;
14708
14709   //argout typemap for const std::string&
14710
14711   return jresult;
14712 }
14713
14714
14715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14716   void * jresult ;
14717   Dali::Handle *arg1 = 0 ;
14718   std::string *arg2 = 0 ;
14719   int arg3 ;
14720   Dali::Property *result = 0 ;
14721
14722   arg1 = (Dali::Handle *)jarg1;
14723   if (!arg1) {
14724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14725     return 0;
14726   }
14727   if (!jarg2) {
14728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14729     return 0;
14730   }
14731   std::string arg2_str(jarg2);
14732   arg2 = &arg2_str;
14733   arg3 = (int)jarg3;
14734   {
14735     try {
14736       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14737     } catch (std::out_of_range& e) {
14738       {
14739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14740       };
14741     } catch (std::exception& e) {
14742       {
14743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14744       };
14745     } catch (Dali::DaliException e) {
14746       {
14747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14748       };
14749     } catch (...) {
14750       {
14751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14752       };
14753     }
14754   }
14755
14756   jresult = (void *)result;
14757
14758   //argout typemap for const std::string&
14759
14760   return jresult;
14761 }
14762
14763
14764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14765   Dali::Property *arg1 = (Dali::Property *) 0 ;
14766
14767   arg1 = (Dali::Property *)jarg1;
14768   {
14769     try {
14770       delete arg1;
14771     } catch (std::out_of_range& e) {
14772       {
14773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14774       };
14775     } catch (std::exception& e) {
14776       {
14777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14778       };
14779     } catch (Dali::DaliException e) {
14780       {
14781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14782       };
14783     } catch (...) {
14784       {
14785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14786       };
14787     }
14788   }
14789
14790 }
14791
14792
14793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14794   Dali::Property *arg1 = (Dali::Property *) 0 ;
14795   Dali::Handle *arg2 = 0 ;
14796
14797   arg1 = (Dali::Property *)jarg1;
14798   arg2 = (Dali::Handle *)jarg2;
14799   if (!arg2) {
14800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14801     return ;
14802   }
14803   if (arg1) (arg1)->object = *arg2;
14804 }
14805
14806
14807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14808   void * jresult ;
14809   Dali::Property *arg1 = (Dali::Property *) 0 ;
14810   Dali::Handle *result = 0 ;
14811
14812   arg1 = (Dali::Property *)jarg1;
14813   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14814   jresult = (void *)result;
14815   return jresult;
14816 }
14817
14818
14819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14820   Dali::Property *arg1 = (Dali::Property *) 0 ;
14821   Dali::Property::Index arg2 ;
14822
14823   arg1 = (Dali::Property *)jarg1;
14824   arg2 = (Dali::Property::Index)jarg2;
14825   if (arg1) (arg1)->propertyIndex = arg2;
14826 }
14827
14828
14829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14830   int jresult ;
14831   Dali::Property *arg1 = (Dali::Property *) 0 ;
14832   Dali::Property::Index result;
14833
14834   arg1 = (Dali::Property *)jarg1;
14835   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14836   jresult = result;
14837   return jresult;
14838 }
14839
14840
14841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14842   Dali::Property *arg1 = (Dali::Property *) 0 ;
14843   int arg2 ;
14844
14845   arg1 = (Dali::Property *)jarg1;
14846   arg2 = (int)jarg2;
14847   if (arg1) (arg1)->componentIndex = arg2;
14848 }
14849
14850
14851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14852   int jresult ;
14853   Dali::Property *arg1 = (Dali::Property *) 0 ;
14854   int result;
14855
14856   arg1 = (Dali::Property *)jarg1;
14857   result = (int) ((arg1)->componentIndex);
14858   jresult = result;
14859   return jresult;
14860 }
14861
14862
14863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14864   void * jresult ;
14865   Dali::Property::Array *result = 0 ;
14866
14867   {
14868     try {
14869       result = (Dali::Property::Array *)new Dali::Property::Array();
14870     } catch (std::out_of_range& e) {
14871       {
14872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14873       };
14874     } catch (std::exception& e) {
14875       {
14876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14877       };
14878     } catch (Dali::DaliException e) {
14879       {
14880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14881       };
14882     } catch (...) {
14883       {
14884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14885       };
14886     }
14887   }
14888
14889   jresult = (void *)result;
14890   return jresult;
14891 }
14892
14893
14894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14895   void * jresult ;
14896   Dali::Property::Array *arg1 = 0 ;
14897   Dali::Property::Array *result = 0 ;
14898
14899   arg1 = (Dali::Property::Array *)jarg1;
14900   if (!arg1) {
14901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14902     return 0;
14903   }
14904   {
14905     try {
14906       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14907     } catch (std::out_of_range& e) {
14908       {
14909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14910       };
14911     } catch (std::exception& e) {
14912       {
14913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14914       };
14915     } catch (Dali::DaliException e) {
14916       {
14917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14918       };
14919     } catch (...) {
14920       {
14921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14922       };
14923     }
14924   }
14925
14926   jresult = (void *)result;
14927   return jresult;
14928 }
14929
14930
14931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14932   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14933
14934   arg1 = (Dali::Property::Array *)jarg1;
14935   {
14936     try {
14937       delete arg1;
14938     } catch (std::out_of_range& e) {
14939       {
14940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14941       };
14942     } catch (std::exception& e) {
14943       {
14944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14945       };
14946     } catch (Dali::DaliException e) {
14947       {
14948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14949       };
14950     } catch (...) {
14951       {
14952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14953       };
14954     }
14955   }
14956
14957 }
14958
14959
14960 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14961   unsigned long jresult ;
14962   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14963   Dali::Property::Array::SizeType result;
14964
14965   arg1 = (Dali::Property::Array *)jarg1;
14966   {
14967     try {
14968       result = ((Dali::Property::Array const *)arg1)->Size();
14969     } catch (std::out_of_range& e) {
14970       {
14971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14972       };
14973     } catch (std::exception& e) {
14974       {
14975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14976       };
14977     } catch (Dali::DaliException e) {
14978       {
14979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14980       };
14981     } catch (...) {
14982       {
14983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14984       };
14985     }
14986   }
14987
14988   jresult = (unsigned long)result;
14989   return jresult;
14990 }
14991
14992
14993 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
14994   unsigned long jresult ;
14995   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14996   Dali::Property::Array::SizeType result;
14997
14998   arg1 = (Dali::Property::Array *)jarg1;
14999   {
15000     try {
15001       result = ((Dali::Property::Array const *)arg1)->Count();
15002     } catch (std::out_of_range& e) {
15003       {
15004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15005       };
15006     } catch (std::exception& e) {
15007       {
15008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15009       };
15010     } catch (Dali::DaliException e) {
15011       {
15012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15013       };
15014     } catch (...) {
15015       {
15016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15017       };
15018     }
15019   }
15020
15021   jresult = (unsigned long)result;
15022   return jresult;
15023 }
15024
15025
15026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15027   unsigned int jresult ;
15028   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15029   bool result;
15030
15031   arg1 = (Dali::Property::Array *)jarg1;
15032   {
15033     try {
15034       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15035     } catch (std::out_of_range& e) {
15036       {
15037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15038       };
15039     } catch (std::exception& e) {
15040       {
15041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15042       };
15043     } catch (Dali::DaliException e) {
15044       {
15045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15046       };
15047     } catch (...) {
15048       {
15049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15050       };
15051     }
15052   }
15053
15054   jresult = result;
15055   return jresult;
15056 }
15057
15058
15059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15060   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15061
15062   arg1 = (Dali::Property::Array *)jarg1;
15063   {
15064     try {
15065       (arg1)->Clear();
15066     } catch (std::out_of_range& e) {
15067       {
15068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15069       };
15070     } catch (std::exception& e) {
15071       {
15072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15073       };
15074     } catch (Dali::DaliException e) {
15075       {
15076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15077       };
15078     } catch (...) {
15079       {
15080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15081       };
15082     }
15083   }
15084
15085 }
15086
15087
15088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15089   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15090   Dali::Property::Array::SizeType arg2 ;
15091
15092   arg1 = (Dali::Property::Array *)jarg1;
15093   arg2 = (Dali::Property::Array::SizeType)jarg2;
15094   {
15095     try {
15096       (arg1)->Reserve(arg2);
15097     } catch (std::out_of_range& e) {
15098       {
15099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15100       };
15101     } catch (std::exception& e) {
15102       {
15103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15104       };
15105     } catch (Dali::DaliException e) {
15106       {
15107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15108       };
15109     } catch (...) {
15110       {
15111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15112       };
15113     }
15114   }
15115
15116 }
15117
15118
15119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15120   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15121   Dali::Property::Array::SizeType arg2 ;
15122
15123   arg1 = (Dali::Property::Array *)jarg1;
15124   arg2 = (Dali::Property::Array::SizeType)jarg2;
15125   {
15126     try {
15127       (arg1)->Resize(arg2);
15128     } catch (std::out_of_range& e) {
15129       {
15130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15131       };
15132     } catch (std::exception& e) {
15133       {
15134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15135       };
15136     } catch (Dali::DaliException e) {
15137       {
15138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15139       };
15140     } catch (...) {
15141       {
15142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15143       };
15144     }
15145   }
15146
15147 }
15148
15149
15150 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15151   unsigned long jresult ;
15152   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15153   Dali::Property::Array::SizeType result;
15154
15155   arg1 = (Dali::Property::Array *)jarg1;
15156   {
15157     try {
15158       result = (arg1)->Capacity();
15159     } catch (std::out_of_range& e) {
15160       {
15161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15162       };
15163     } catch (std::exception& e) {
15164       {
15165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15166       };
15167     } catch (Dali::DaliException e) {
15168       {
15169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15170       };
15171     } catch (...) {
15172       {
15173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15174       };
15175     }
15176   }
15177
15178   jresult = (unsigned long)result;
15179   return jresult;
15180 }
15181
15182
15183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15184   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15185   Dali::Property::Value *arg2 = 0 ;
15186
15187   arg1 = (Dali::Property::Array *)jarg1;
15188   arg2 = (Dali::Property::Value *)jarg2;
15189   if (!arg2) {
15190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15191     return ;
15192   }
15193   {
15194     try {
15195       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15196     } catch (std::out_of_range& e) {
15197       {
15198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15199       };
15200     } catch (std::exception& e) {
15201       {
15202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15203       };
15204     } catch (Dali::DaliException e) {
15205       {
15206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15207       };
15208     } catch (...) {
15209       {
15210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15211       };
15212     }
15213   }
15214
15215 }
15216
15217
15218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15219   void * jresult ;
15220   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15221   Dali::Property::Value *arg2 = 0 ;
15222   Dali::Property::Array *result = 0 ;
15223
15224   arg1 = (Dali::Property::Array *)jarg1;
15225   arg2 = (Dali::Property::Value *)jarg2;
15226   if (!arg2) {
15227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15228     return 0;
15229   }
15230   {
15231     try {
15232       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15233     } catch (std::out_of_range& e) {
15234       {
15235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15236       };
15237     } catch (std::exception& e) {
15238       {
15239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15240       };
15241     } catch (Dali::DaliException e) {
15242       {
15243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15244       };
15245     } catch (...) {
15246       {
15247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15248       };
15249     }
15250   }
15251
15252   jresult = (void *)result;
15253   return jresult;
15254 }
15255
15256
15257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15258   void * jresult ;
15259   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15260   Dali::Property::Array::SizeType arg2 ;
15261   Dali::Property::Value *result = 0 ;
15262
15263   arg1 = (Dali::Property::Array *)jarg1;
15264   arg2 = (Dali::Property::Array::SizeType)jarg2;
15265   {
15266     try {
15267       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15268     } catch (std::out_of_range& e) {
15269       {
15270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15271       };
15272     } catch (std::exception& e) {
15273       {
15274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15275       };
15276     } catch (Dali::DaliException e) {
15277       {
15278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15279       };
15280     } catch (...) {
15281       {
15282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15283       };
15284     }
15285   }
15286
15287   jresult = (void *)result;
15288   return jresult;
15289 }
15290
15291
15292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15293   void * jresult ;
15294   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15295   Dali::Property::Array::SizeType arg2 ;
15296   Dali::Property::Value *result = 0 ;
15297
15298   arg1 = (Dali::Property::Array *)jarg1;
15299   arg2 = (Dali::Property::Array::SizeType)jarg2;
15300   {
15301     try {
15302       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15303     } catch (std::out_of_range& e) {
15304       {
15305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15306       };
15307     } catch (std::exception& e) {
15308       {
15309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15310       };
15311     } catch (Dali::DaliException e) {
15312       {
15313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15314       };
15315     } catch (...) {
15316       {
15317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15318       };
15319     }
15320   }
15321
15322   jresult = (void *)result;
15323   return jresult;
15324 }
15325
15326
15327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15328   void * jresult ;
15329   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15330   Dali::Property::Array *arg2 = 0 ;
15331   Dali::Property::Array *result = 0 ;
15332
15333   arg1 = (Dali::Property::Array *)jarg1;
15334   arg2 = (Dali::Property::Array *)jarg2;
15335   if (!arg2) {
15336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15337     return 0;
15338   }
15339   {
15340     try {
15341       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15342     } catch (std::out_of_range& e) {
15343       {
15344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15345       };
15346     } catch (std::exception& e) {
15347       {
15348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15349       };
15350     } catch (Dali::DaliException e) {
15351       {
15352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15353       };
15354     } catch (...) {
15355       {
15356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15357       };
15358     }
15359   }
15360
15361   jresult = (void *)result;
15362   return jresult;
15363 }
15364
15365
15366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15367   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15368   enum Dali::Property::Key::Type arg2 ;
15369
15370   arg1 = (Dali::Property::Key *)jarg1;
15371   arg2 = (enum Dali::Property::Key::Type)jarg2;
15372   if (arg1) (arg1)->type = arg2;
15373 }
15374
15375
15376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15377   int jresult ;
15378   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15379   enum Dali::Property::Key::Type result;
15380
15381   arg1 = (Dali::Property::Key *)jarg1;
15382   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15383   jresult = (int)result;
15384   return jresult;
15385 }
15386
15387
15388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15389   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15390   Dali::Property::Index arg2 ;
15391
15392   arg1 = (Dali::Property::Key *)jarg1;
15393   arg2 = (Dali::Property::Index)jarg2;
15394   if (arg1) (arg1)->indexKey = arg2;
15395 }
15396
15397
15398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15399   int jresult ;
15400   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15401   Dali::Property::Index result;
15402
15403   arg1 = (Dali::Property::Key *)jarg1;
15404   result = (Dali::Property::Index) ((arg1)->indexKey);
15405   jresult = result;
15406   return jresult;
15407 }
15408
15409
15410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15411   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15412   std::string *arg2 = 0 ;
15413
15414   arg1 = (Dali::Property::Key *)jarg1;
15415   if (!jarg2) {
15416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15417     return ;
15418   }
15419   std::string arg2_str(jarg2);
15420   arg2 = &arg2_str;
15421   if (arg1) (arg1)->stringKey = *arg2;
15422
15423   //argout typemap for const std::string&
15424
15425 }
15426
15427
15428 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15429   char * jresult ;
15430   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15431   std::string *result = 0 ;
15432
15433   arg1 = (Dali::Property::Key *)jarg1;
15434   result = (std::string *) & ((arg1)->stringKey);
15435   jresult = SWIG_csharp_string_callback(result->c_str());
15436   return jresult;
15437 }
15438
15439
15440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15441   void * jresult ;
15442   std::string *arg1 = 0 ;
15443   Dali::Property::Key *result = 0 ;
15444
15445   if (!jarg1) {
15446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15447     return 0;
15448   }
15449   std::string arg1_str(jarg1);
15450   arg1 = &arg1_str;
15451   {
15452     try {
15453       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15454     } catch (std::out_of_range& e) {
15455       {
15456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15457       };
15458     } catch (std::exception& e) {
15459       {
15460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15461       };
15462     } catch (Dali::DaliException e) {
15463       {
15464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15465       };
15466     } catch (...) {
15467       {
15468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15469       };
15470     }
15471   }
15472
15473   jresult = (void *)result;
15474
15475   //argout typemap for const std::string&
15476
15477   return jresult;
15478 }
15479
15480
15481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15482   void * jresult ;
15483   Dali::Property::Index arg1 ;
15484   Dali::Property::Key *result = 0 ;
15485
15486   arg1 = (Dali::Property::Index)jarg1;
15487   {
15488     try {
15489       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15490     } catch (std::out_of_range& e) {
15491       {
15492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15493       };
15494     } catch (std::exception& e) {
15495       {
15496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15497       };
15498     } catch (Dali::DaliException e) {
15499       {
15500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15501       };
15502     } catch (...) {
15503       {
15504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15505       };
15506     }
15507   }
15508
15509   jresult = (void *)result;
15510   return jresult;
15511 }
15512
15513
15514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15515   unsigned int jresult ;
15516   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15517   std::string *arg2 = 0 ;
15518   bool result;
15519
15520   arg1 = (Dali::Property::Key *)jarg1;
15521   if (!jarg2) {
15522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15523     return 0;
15524   }
15525   std::string arg2_str(jarg2);
15526   arg2 = &arg2_str;
15527   {
15528     try {
15529       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15530     } catch (std::out_of_range& e) {
15531       {
15532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15533       };
15534     } catch (std::exception& e) {
15535       {
15536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15537       };
15538     } catch (Dali::DaliException e) {
15539       {
15540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15541       };
15542     } catch (...) {
15543       {
15544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15545       };
15546     }
15547   }
15548
15549   jresult = result;
15550
15551   //argout typemap for const std::string&
15552
15553   return jresult;
15554 }
15555
15556
15557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15558   unsigned int jresult ;
15559   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15560   Dali::Property::Index arg2 ;
15561   bool result;
15562
15563   arg1 = (Dali::Property::Key *)jarg1;
15564   arg2 = (Dali::Property::Index)jarg2;
15565   {
15566     try {
15567       result = (bool)(arg1)->operator ==(arg2);
15568     } catch (std::out_of_range& e) {
15569       {
15570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15571       };
15572     } catch (std::exception& e) {
15573       {
15574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15575       };
15576     } catch (Dali::DaliException e) {
15577       {
15578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15579       };
15580     } catch (...) {
15581       {
15582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15583       };
15584     }
15585   }
15586
15587   jresult = result;
15588   return jresult;
15589 }
15590
15591
15592 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15593   unsigned int jresult ;
15594   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15595   Dali::Property::Key *arg2 = 0 ;
15596   bool result;
15597
15598   arg1 = (Dali::Property::Key *)jarg1;
15599   arg2 = (Dali::Property::Key *)jarg2;
15600   if (!arg2) {
15601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15602     return 0;
15603   }
15604   {
15605     try {
15606       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15607     } catch (std::out_of_range& e) {
15608       {
15609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15610       };
15611     } catch (std::exception& e) {
15612       {
15613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15614       };
15615     } catch (Dali::DaliException e) {
15616       {
15617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15618       };
15619     } catch (...) {
15620       {
15621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15622       };
15623     }
15624   }
15625
15626   jresult = result;
15627   return jresult;
15628 }
15629
15630
15631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15632   unsigned int jresult ;
15633   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15634   std::string *arg2 = 0 ;
15635   bool result;
15636
15637   arg1 = (Dali::Property::Key *)jarg1;
15638   if (!jarg2) {
15639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15640     return 0;
15641   }
15642   std::string arg2_str(jarg2);
15643   arg2 = &arg2_str;
15644   {
15645     try {
15646       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15647     } catch (std::out_of_range& e) {
15648       {
15649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15650       };
15651     } catch (std::exception& e) {
15652       {
15653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15654       };
15655     } catch (Dali::DaliException e) {
15656       {
15657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15658       };
15659     } catch (...) {
15660       {
15661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15662       };
15663     }
15664   }
15665
15666   jresult = result;
15667
15668   //argout typemap for const std::string&
15669
15670   return jresult;
15671 }
15672
15673
15674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15675   unsigned int jresult ;
15676   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15677   Dali::Property::Index arg2 ;
15678   bool result;
15679
15680   arg1 = (Dali::Property::Key *)jarg1;
15681   arg2 = (Dali::Property::Index)jarg2;
15682   {
15683     try {
15684       result = (bool)(arg1)->operator !=(arg2);
15685     } catch (std::out_of_range& e) {
15686       {
15687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15688       };
15689     } catch (std::exception& e) {
15690       {
15691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15692       };
15693     } catch (Dali::DaliException e) {
15694       {
15695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15696       };
15697     } catch (...) {
15698       {
15699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15700       };
15701     }
15702   }
15703
15704   jresult = result;
15705   return jresult;
15706 }
15707
15708
15709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15710   unsigned int jresult ;
15711   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15712   Dali::Property::Key *arg2 = 0 ;
15713   bool result;
15714
15715   arg1 = (Dali::Property::Key *)jarg1;
15716   arg2 = (Dali::Property::Key *)jarg2;
15717   if (!arg2) {
15718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15719     return 0;
15720   }
15721   {
15722     try {
15723       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15724     } catch (std::out_of_range& e) {
15725       {
15726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15727       };
15728     } catch (std::exception& e) {
15729       {
15730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15731       };
15732     } catch (Dali::DaliException e) {
15733       {
15734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15735       };
15736     } catch (...) {
15737       {
15738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15739       };
15740     }
15741   }
15742
15743   jresult = result;
15744   return jresult;
15745 }
15746
15747
15748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15749   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15750
15751   arg1 = (Dali::Property::Key *)jarg1;
15752   {
15753     try {
15754       delete arg1;
15755     } catch (std::out_of_range& e) {
15756       {
15757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15758       };
15759     } catch (std::exception& e) {
15760       {
15761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15762       };
15763     } catch (Dali::DaliException e) {
15764       {
15765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15766       };
15767     } catch (...) {
15768       {
15769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15770       };
15771     }
15772   }
15773
15774 }
15775
15776
15777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15778   void * jresult ;
15779   Dali::Property::Map *result = 0 ;
15780
15781   {
15782     try {
15783       result = (Dali::Property::Map *)new Dali::Property::Map();
15784     } catch (std::out_of_range& e) {
15785       {
15786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15787       };
15788     } catch (std::exception& e) {
15789       {
15790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15791       };
15792     } catch (Dali::DaliException e) {
15793       {
15794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15795       };
15796     } catch (...) {
15797       {
15798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15799       };
15800     }
15801   }
15802
15803   jresult = (void *)result;
15804   return jresult;
15805 }
15806
15807
15808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15809   void * jresult ;
15810   Dali::Property::Map *arg1 = 0 ;
15811   Dali::Property::Map *result = 0 ;
15812
15813   arg1 = (Dali::Property::Map *)jarg1;
15814   if (!arg1) {
15815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15816     return 0;
15817   }
15818   {
15819     try {
15820       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15821     } catch (std::out_of_range& e) {
15822       {
15823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15824       };
15825     } catch (std::exception& e) {
15826       {
15827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15828       };
15829     } catch (Dali::DaliException e) {
15830       {
15831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15832       };
15833     } catch (...) {
15834       {
15835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15836       };
15837     }
15838   }
15839
15840   jresult = (void *)result;
15841   return jresult;
15842 }
15843
15844
15845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15846   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15847
15848   arg1 = (Dali::Property::Map *)jarg1;
15849   {
15850     try {
15851       delete arg1;
15852     } catch (std::out_of_range& e) {
15853       {
15854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15855       };
15856     } catch (std::exception& e) {
15857       {
15858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15859       };
15860     } catch (Dali::DaliException e) {
15861       {
15862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15863       };
15864     } catch (...) {
15865       {
15866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15867       };
15868     }
15869   }
15870
15871 }
15872
15873
15874 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15875   unsigned long jresult ;
15876   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15877   Dali::Property::Map::SizeType result;
15878
15879   arg1 = (Dali::Property::Map *)jarg1;
15880   {
15881     try {
15882       result = ((Dali::Property::Map const *)arg1)->Count();
15883     } catch (std::out_of_range& e) {
15884       {
15885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15886       };
15887     } catch (std::exception& e) {
15888       {
15889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15890       };
15891     } catch (Dali::DaliException e) {
15892       {
15893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15894       };
15895     } catch (...) {
15896       {
15897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15898       };
15899     }
15900   }
15901
15902   jresult = (unsigned long)result;
15903   return jresult;
15904 }
15905
15906
15907 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15908   unsigned int jresult ;
15909   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15910   bool result;
15911
15912   arg1 = (Dali::Property::Map *)jarg1;
15913   {
15914     try {
15915       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15916     } catch (std::out_of_range& e) {
15917       {
15918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15919       };
15920     } catch (std::exception& e) {
15921       {
15922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15923       };
15924     } catch (Dali::DaliException e) {
15925       {
15926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15927       };
15928     } catch (...) {
15929       {
15930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15931       };
15932     }
15933   }
15934
15935   jresult = result;
15936   return jresult;
15937 }
15938
15939
15940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15941   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15942   char *arg2 = (char *) 0 ;
15943   Dali::Property::Value *arg3 = 0 ;
15944
15945   arg1 = (Dali::Property::Map *)jarg1;
15946   arg2 = (char *)jarg2;
15947   arg3 = (Dali::Property::Value *)jarg3;
15948   if (!arg3) {
15949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15950     return ;
15951   }
15952   {
15953     try {
15954       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15955     } catch (std::out_of_range& e) {
15956       {
15957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15958       };
15959     } catch (std::exception& e) {
15960       {
15961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15962       };
15963     } catch (Dali::DaliException e) {
15964       {
15965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15966       };
15967     } catch (...) {
15968       {
15969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15970       };
15971     }
15972   }
15973
15974 }
15975
15976
15977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
15978   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15979   Dali::Property::Index arg2 ;
15980   Dali::Property::Value *arg3 = 0 ;
15981
15982   arg1 = (Dali::Property::Map *)jarg1;
15983   arg2 = (Dali::Property::Index)jarg2;
15984   arg3 = (Dali::Property::Value *)jarg3;
15985   if (!arg3) {
15986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15987     return ;
15988   }
15989   {
15990     try {
15991       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
15992     } catch (std::out_of_range& e) {
15993       {
15994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15995       };
15996     } catch (std::exception& e) {
15997       {
15998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15999       };
16000     } catch (Dali::DaliException e) {
16001       {
16002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16003       };
16004     } catch (...) {
16005       {
16006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16007       };
16008     }
16009   }
16010
16011 }
16012
16013
16014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16015   void * jresult ;
16016   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16017   char *arg2 = (char *) 0 ;
16018   Dali::Property::Value *arg3 = 0 ;
16019   Dali::Property::Map *result = 0 ;
16020
16021   arg1 = (Dali::Property::Map *)jarg1;
16022   arg2 = (char *)jarg2;
16023   arg3 = (Dali::Property::Value *)jarg3;
16024   if (!arg3) {
16025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16026     return 0;
16027   }
16028   {
16029     try {
16030       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16031     } catch (std::out_of_range& e) {
16032       {
16033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16034       };
16035     } catch (std::exception& e) {
16036       {
16037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16038       };
16039     } catch (Dali::DaliException e) {
16040       {
16041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16042       };
16043     } catch (...) {
16044       {
16045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16046       };
16047     }
16048   }
16049
16050   jresult = (void *)result;
16051   return jresult;
16052 }
16053
16054
16055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16056   void * jresult ;
16057   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16058   Dali::Property::Index arg2 ;
16059   Dali::Property::Value *arg3 = 0 ;
16060   Dali::Property::Map *result = 0 ;
16061
16062   arg1 = (Dali::Property::Map *)jarg1;
16063   arg2 = (Dali::Property::Index)jarg2;
16064   arg3 = (Dali::Property::Value *)jarg3;
16065   if (!arg3) {
16066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16067     return 0;
16068   }
16069   {
16070     try {
16071       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16072     } catch (std::out_of_range& e) {
16073       {
16074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16075       };
16076     } catch (std::exception& e) {
16077       {
16078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16079       };
16080     } catch (Dali::DaliException e) {
16081       {
16082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16083       };
16084     } catch (...) {
16085       {
16086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16087       };
16088     }
16089   }
16090
16091   jresult = (void *)result;
16092   return jresult;
16093 }
16094
16095
16096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16097   void * jresult ;
16098   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16099   Dali::Property::Map::SizeType arg2 ;
16100   Dali::Property::Value *result = 0 ;
16101
16102   arg1 = (Dali::Property::Map *)jarg1;
16103   arg2 = (Dali::Property::Map::SizeType)jarg2;
16104   {
16105     try {
16106       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16107     } catch (std::out_of_range& e) {
16108       {
16109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16110       };
16111     } catch (std::exception& e) {
16112       {
16113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16114       };
16115     } catch (Dali::DaliException e) {
16116       {
16117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16118       };
16119     } catch (...) {
16120       {
16121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16122       };
16123     }
16124   }
16125
16126   jresult = (void *)result;
16127   return jresult;
16128 }
16129
16130
16131 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16132   char * jresult ;
16133   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16134   Dali::Property::Map::SizeType arg2 ;
16135   std::string *result = 0 ;
16136
16137   arg1 = (Dali::Property::Map *)jarg1;
16138   arg2 = (Dali::Property::Map::SizeType)jarg2;
16139   {
16140     try {
16141       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16142     } catch (std::out_of_range& e) {
16143       {
16144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16145       };
16146     } catch (std::exception& e) {
16147       {
16148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16149       };
16150     } catch (Dali::DaliException e) {
16151       {
16152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16153       };
16154     } catch (...) {
16155       {
16156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16157       };
16158     }
16159   }
16160
16161   jresult = SWIG_csharp_string_callback(result->c_str());
16162   return jresult;
16163 }
16164
16165
16166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16167   void * jresult ;
16168   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16169   Dali::Property::Map::SizeType arg2 ;
16170   SwigValueWrapper< Dali::Property::Key > result;
16171
16172   arg1 = (Dali::Property::Map *)jarg1;
16173   arg2 = (Dali::Property::Map::SizeType)jarg2;
16174   {
16175     try {
16176       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16177     } catch (std::out_of_range& e) {
16178       {
16179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16180       };
16181     } catch (std::exception& e) {
16182       {
16183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16184       };
16185     } catch (Dali::DaliException e) {
16186       {
16187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16188       };
16189     } catch (...) {
16190       {
16191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16192       };
16193     }
16194   }
16195
16196   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16197   return jresult;
16198 }
16199
16200
16201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16202   void * jresult ;
16203   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16204   Dali::Property::Map::SizeType arg2 ;
16205   StringValuePair *result = 0 ;
16206
16207   arg1 = (Dali::Property::Map *)jarg1;
16208   arg2 = (Dali::Property::Map::SizeType)jarg2;
16209   {
16210     try {
16211       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16212     } catch (std::out_of_range& e) {
16213       {
16214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16215       };
16216     } catch (std::exception& e) {
16217       {
16218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16219       };
16220     } catch (Dali::DaliException e) {
16221       {
16222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16223       };
16224     } catch (...) {
16225       {
16226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16227       };
16228     }
16229   }
16230
16231   jresult = (void *)result;
16232   return jresult;
16233 }
16234
16235
16236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16237   void * jresult ;
16238   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16239   char *arg2 = (char *) 0 ;
16240   Dali::Property::Value *result = 0 ;
16241
16242   arg1 = (Dali::Property::Map *)jarg1;
16243   arg2 = (char *)jarg2;
16244   {
16245     try {
16246       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16247     } catch (std::out_of_range& e) {
16248       {
16249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16250       };
16251     } catch (std::exception& e) {
16252       {
16253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16254       };
16255     } catch (Dali::DaliException e) {
16256       {
16257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16258       };
16259     } catch (...) {
16260       {
16261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16262       };
16263     }
16264   }
16265
16266   jresult = (void *)result;
16267   return jresult;
16268 }
16269
16270
16271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16272   void * jresult ;
16273   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16274   Dali::Property::Index arg2 ;
16275   Dali::Property::Value *result = 0 ;
16276
16277   arg1 = (Dali::Property::Map *)jarg1;
16278   arg2 = (Dali::Property::Index)jarg2;
16279   {
16280     try {
16281       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16282     } catch (std::out_of_range& e) {
16283       {
16284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16285       };
16286     } catch (std::exception& e) {
16287       {
16288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16289       };
16290     } catch (Dali::DaliException e) {
16291       {
16292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16293       };
16294     } catch (...) {
16295       {
16296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16297       };
16298     }
16299   }
16300
16301   jresult = (void *)result;
16302   return jresult;
16303 }
16304
16305
16306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16307   void * jresult ;
16308   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16309   Dali::Property::Index arg2 ;
16310   std::string *arg3 = 0 ;
16311   Dali::Property::Value *result = 0 ;
16312
16313   arg1 = (Dali::Property::Map *)jarg1;
16314   arg2 = (Dali::Property::Index)jarg2;
16315   if (!jarg3) {
16316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16317     return 0;
16318   }
16319   std::string arg3_str(jarg3);
16320   arg3 = &arg3_str;
16321   {
16322     try {
16323       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16324     } catch (std::out_of_range& e) {
16325       {
16326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16327       };
16328     } catch (std::exception& e) {
16329       {
16330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16331       };
16332     } catch (Dali::DaliException e) {
16333       {
16334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16335       };
16336     } catch (...) {
16337       {
16338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16339       };
16340     }
16341   }
16342
16343   jresult = (void *)result;
16344
16345   //argout typemap for const std::string&
16346
16347   return jresult;
16348 }
16349
16350
16351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16352   void * jresult ;
16353   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16354   std::string *arg2 = 0 ;
16355   Dali::Property::Type arg3 ;
16356   Dali::Property::Value *result = 0 ;
16357
16358   arg1 = (Dali::Property::Map *)jarg1;
16359   if (!jarg2) {
16360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16361     return 0;
16362   }
16363   std::string arg2_str(jarg2);
16364   arg2 = &arg2_str;
16365   arg3 = (Dali::Property::Type)jarg3;
16366   {
16367     try {
16368       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16369     } catch (std::out_of_range& e) {
16370       {
16371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16372       };
16373     } catch (std::exception& e) {
16374       {
16375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16376       };
16377     } catch (Dali::DaliException e) {
16378       {
16379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16380       };
16381     } catch (...) {
16382       {
16383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16384       };
16385     }
16386   }
16387
16388   jresult = (void *)result;
16389
16390   //argout typemap for const std::string&
16391
16392   return jresult;
16393 }
16394
16395
16396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16397   void * jresult ;
16398   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16399   Dali::Property::Index arg2 ;
16400   Dali::Property::Type arg3 ;
16401   Dali::Property::Value *result = 0 ;
16402
16403   arg1 = (Dali::Property::Map *)jarg1;
16404   arg2 = (Dali::Property::Index)jarg2;
16405   arg3 = (Dali::Property::Type)jarg3;
16406   {
16407     try {
16408       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16409     } catch (std::out_of_range& e) {
16410       {
16411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16412       };
16413     } catch (std::exception& e) {
16414       {
16415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16416       };
16417     } catch (Dali::DaliException e) {
16418       {
16419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16420       };
16421     } catch (...) {
16422       {
16423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16424       };
16425     }
16426   }
16427
16428   jresult = (void *)result;
16429   return jresult;
16430 }
16431
16432
16433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16434   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16435
16436   arg1 = (Dali::Property::Map *)jarg1;
16437   {
16438     try {
16439       (arg1)->Clear();
16440     } catch (std::out_of_range& e) {
16441       {
16442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16443       };
16444     } catch (std::exception& e) {
16445       {
16446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16447       };
16448     } catch (Dali::DaliException e) {
16449       {
16450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16451       };
16452     } catch (...) {
16453       {
16454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16455       };
16456     }
16457   }
16458
16459 }
16460
16461
16462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16463   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16464   Dali::Property::Map *arg2 = 0 ;
16465
16466   arg1 = (Dali::Property::Map *)jarg1;
16467   arg2 = (Dali::Property::Map *)jarg2;
16468   if (!arg2) {
16469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16470     return ;
16471   }
16472   {
16473     try {
16474       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16475     } catch (std::out_of_range& e) {
16476       {
16477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16478       };
16479     } catch (std::exception& e) {
16480       {
16481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16482       };
16483     } catch (Dali::DaliException e) {
16484       {
16485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16486       };
16487     } catch (...) {
16488       {
16489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16490       };
16491     }
16492   }
16493
16494 }
16495
16496
16497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16498   void * jresult ;
16499   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16500   std::string *arg2 = 0 ;
16501   Dali::Property::Value *result = 0 ;
16502
16503   arg1 = (Dali::Property::Map *)jarg1;
16504   if (!jarg2) {
16505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16506     return 0;
16507   }
16508   std::string arg2_str(jarg2);
16509   arg2 = &arg2_str;
16510   {
16511     try {
16512       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16513     } catch (std::out_of_range& e) {
16514       {
16515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16516       };
16517     } catch (std::exception& e) {
16518       {
16519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16520       };
16521     } catch (Dali::DaliException e) {
16522       {
16523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16524       };
16525     } catch (...) {
16526       {
16527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16528       };
16529     }
16530   }
16531
16532   jresult = (void *)result;
16533
16534   //argout typemap for const std::string&
16535
16536   return jresult;
16537 }
16538
16539
16540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16541   void * jresult ;
16542   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16543   Dali::Property::Index arg2 ;
16544   Dali::Property::Value *result = 0 ;
16545
16546   arg1 = (Dali::Property::Map *)jarg1;
16547   arg2 = (Dali::Property::Index)jarg2;
16548   {
16549     try {
16550       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16551     } catch (std::out_of_range& e) {
16552       {
16553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16554       };
16555     } catch (std::exception& e) {
16556       {
16557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16558       };
16559     } catch (Dali::DaliException e) {
16560       {
16561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16562       };
16563     } catch (...) {
16564       {
16565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16566       };
16567     }
16568   }
16569
16570   jresult = (void *)result;
16571   return jresult;
16572 }
16573
16574
16575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16576   void * jresult ;
16577   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16578   Dali::Property::Map *arg2 = 0 ;
16579   Dali::Property::Map *result = 0 ;
16580
16581   arg1 = (Dali::Property::Map *)jarg1;
16582   arg2 = (Dali::Property::Map *)jarg2;
16583   if (!arg2) {
16584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16585     return 0;
16586   }
16587   {
16588     try {
16589       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16590     } catch (std::out_of_range& e) {
16591       {
16592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16593       };
16594     } catch (std::exception& e) {
16595       {
16596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16597       };
16598     } catch (Dali::DaliException e) {
16599       {
16600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16601       };
16602     } catch (...) {
16603       {
16604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16605       };
16606     }
16607   }
16608
16609   jresult = (void *)result;
16610   return jresult;
16611 }
16612
16613
16614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
16615
16616   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16617
16618   if (!jarg2) {
16619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16620     return;
16621   }
16622   std::string arg2_str(jarg2);
16623   std::string* arg2 = &arg2_str;
16624
16625   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16626
16627   {
16628     try {
16629       arg1->operator[]((std::string const &)*arg2) = *arg3;
16630     } catch (std::out_of_range& e) {
16631       {
16632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16633       };
16634     } catch (std::exception& e) {
16635       {
16636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16637       };
16638     } catch (Dali::DaliException e) {
16639       {
16640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16641       };
16642     } catch (...) {
16643       {
16644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16645       };
16646     }
16647   }
16648 }
16649
16650
16651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
16652
16653   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16654   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
16655   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16656
16657   {
16658     try {
16659       arg1->operator[](arg2) = *arg3;
16660     } catch (std::out_of_range& e) {
16661       {
16662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16663       };
16664     } catch (std::exception& e) {
16665       {
16666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16667       };
16668     } catch (Dali::DaliException e) {
16669       {
16670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16671       };
16672     } catch (...) {
16673       {
16674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16675       };
16676     }
16677   }
16678 }
16679
16680
16681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16682   void * jresult ;
16683   Dali::Property::Value *result = 0 ;
16684
16685   {
16686     try {
16687       result = (Dali::Property::Value *)new Dali::Property::Value();
16688     } catch (std::out_of_range& e) {
16689       {
16690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16691       };
16692     } catch (std::exception& e) {
16693       {
16694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16695       };
16696     } catch (Dali::DaliException e) {
16697       {
16698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16699       };
16700     } catch (...) {
16701       {
16702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16703       };
16704     }
16705   }
16706
16707   jresult = (void *)result;
16708   return jresult;
16709 }
16710
16711
16712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16713   void * jresult ;
16714   bool arg1 ;
16715   Dali::Property::Value *result = 0 ;
16716
16717   arg1 = jarg1 ? true : false;
16718   {
16719     try {
16720       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16721     } catch (std::out_of_range& e) {
16722       {
16723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16724       };
16725     } catch (std::exception& e) {
16726       {
16727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16728       };
16729     } catch (Dali::DaliException e) {
16730       {
16731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16732       };
16733     } catch (...) {
16734       {
16735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16736       };
16737     }
16738   }
16739
16740   jresult = (void *)result;
16741   return jresult;
16742 }
16743
16744
16745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16746   void * jresult ;
16747   int arg1 ;
16748   Dali::Property::Value *result = 0 ;
16749
16750   arg1 = (int)jarg1;
16751   {
16752     try {
16753       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16754     } catch (std::out_of_range& e) {
16755       {
16756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16757       };
16758     } catch (std::exception& e) {
16759       {
16760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16761       };
16762     } catch (Dali::DaliException e) {
16763       {
16764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16765       };
16766     } catch (...) {
16767       {
16768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16769       };
16770     }
16771   }
16772
16773   jresult = (void *)result;
16774   return jresult;
16775 }
16776
16777
16778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16779   void * jresult ;
16780   float arg1 ;
16781   Dali::Property::Value *result = 0 ;
16782
16783   arg1 = (float)jarg1;
16784   {
16785     try {
16786       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16787     } catch (std::out_of_range& e) {
16788       {
16789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16790       };
16791     } catch (std::exception& e) {
16792       {
16793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16794       };
16795     } catch (Dali::DaliException e) {
16796       {
16797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16798       };
16799     } catch (...) {
16800       {
16801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16802       };
16803     }
16804   }
16805
16806   jresult = (void *)result;
16807   return jresult;
16808 }
16809
16810
16811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16812   void * jresult ;
16813   Dali::Vector2 *arg1 = 0 ;
16814   Dali::Property::Value *result = 0 ;
16815
16816   arg1 = (Dali::Vector2 *)jarg1;
16817   if (!arg1) {
16818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16819     return 0;
16820   }
16821   {
16822     try {
16823       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16824     } catch (std::out_of_range& e) {
16825       {
16826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16827       };
16828     } catch (std::exception& e) {
16829       {
16830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16831       };
16832     } catch (Dali::DaliException e) {
16833       {
16834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16835       };
16836     } catch (...) {
16837       {
16838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16839       };
16840     }
16841   }
16842
16843   jresult = (void *)result;
16844   return jresult;
16845 }
16846
16847
16848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16849   void * jresult ;
16850   Dali::Vector3 *arg1 = 0 ;
16851   Dali::Property::Value *result = 0 ;
16852
16853   arg1 = (Dali::Vector3 *)jarg1;
16854   if (!arg1) {
16855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16856     return 0;
16857   }
16858   {
16859     try {
16860       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16861     } catch (std::out_of_range& e) {
16862       {
16863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16864       };
16865     } catch (std::exception& e) {
16866       {
16867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16868       };
16869     } catch (Dali::DaliException e) {
16870       {
16871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16872       };
16873     } catch (...) {
16874       {
16875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16876       };
16877     }
16878   }
16879
16880   jresult = (void *)result;
16881   return jresult;
16882 }
16883
16884
16885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16886   void * jresult ;
16887   Dali::Vector4 *arg1 = 0 ;
16888   Dali::Property::Value *result = 0 ;
16889
16890   arg1 = (Dali::Vector4 *)jarg1;
16891   if (!arg1) {
16892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16893     return 0;
16894   }
16895   {
16896     try {
16897       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16898     } catch (std::out_of_range& e) {
16899       {
16900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16901       };
16902     } catch (std::exception& e) {
16903       {
16904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16905       };
16906     } catch (Dali::DaliException e) {
16907       {
16908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16909       };
16910     } catch (...) {
16911       {
16912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16913       };
16914     }
16915   }
16916
16917   jresult = (void *)result;
16918   return jresult;
16919 }
16920
16921
16922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16923   void * jresult ;
16924   Dali::Matrix3 *arg1 = 0 ;
16925   Dali::Property::Value *result = 0 ;
16926
16927   arg1 = (Dali::Matrix3 *)jarg1;
16928   if (!arg1) {
16929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16930     return 0;
16931   }
16932   {
16933     try {
16934       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16935     } catch (std::out_of_range& e) {
16936       {
16937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16938       };
16939     } catch (std::exception& e) {
16940       {
16941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16942       };
16943     } catch (Dali::DaliException e) {
16944       {
16945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16946       };
16947     } catch (...) {
16948       {
16949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16950       };
16951     }
16952   }
16953
16954   jresult = (void *)result;
16955   return jresult;
16956 }
16957
16958
16959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16960   void * jresult ;
16961   Dali::Matrix *arg1 = 0 ;
16962   Dali::Property::Value *result = 0 ;
16963
16964   arg1 = (Dali::Matrix *)jarg1;
16965   if (!arg1) {
16966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16967     return 0;
16968   }
16969   {
16970     try {
16971       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16972     } catch (std::out_of_range& e) {
16973       {
16974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16975       };
16976     } catch (std::exception& e) {
16977       {
16978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16979       };
16980     } catch (Dali::DaliException e) {
16981       {
16982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16983       };
16984     } catch (...) {
16985       {
16986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16987       };
16988     }
16989   }
16990
16991   jresult = (void *)result;
16992   return jresult;
16993 }
16994
16995
16996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16997   void * jresult ;
16998   Dali::Rect< int > *arg1 = 0 ;
16999   Dali::Property::Value *result = 0 ;
17000
17001   arg1 = (Dali::Rect< int > *)jarg1;
17002   if (!arg1) {
17003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
17004     return 0;
17005   }
17006   {
17007     try {
17008       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
17009     } catch (std::out_of_range& e) {
17010       {
17011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17012       };
17013     } catch (std::exception& e) {
17014       {
17015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17016       };
17017     } catch (Dali::DaliException e) {
17018       {
17019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17020       };
17021     } catch (...) {
17022       {
17023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17024       };
17025     }
17026   }
17027
17028   jresult = (void *)result;
17029   return jresult;
17030 }
17031
17032
17033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
17034   void * jresult ;
17035   Dali::AngleAxis *arg1 = 0 ;
17036   Dali::Property::Value *result = 0 ;
17037
17038   arg1 = (Dali::AngleAxis *)jarg1;
17039   if (!arg1) {
17040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17041     return 0;
17042   }
17043   {
17044     try {
17045       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17046     } catch (std::out_of_range& e) {
17047       {
17048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17049       };
17050     } catch (std::exception& e) {
17051       {
17052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17053       };
17054     } catch (Dali::DaliException e) {
17055       {
17056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17057       };
17058     } catch (...) {
17059       {
17060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17061       };
17062     }
17063   }
17064
17065   jresult = (void *)result;
17066   return jresult;
17067 }
17068
17069
17070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17071   void * jresult ;
17072   Dali::Quaternion *arg1 = 0 ;
17073   Dali::Property::Value *result = 0 ;
17074
17075   arg1 = (Dali::Quaternion *)jarg1;
17076   if (!arg1) {
17077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17078     return 0;
17079   }
17080   {
17081     try {
17082       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17083     } catch (std::out_of_range& e) {
17084       {
17085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17086       };
17087     } catch (std::exception& e) {
17088       {
17089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17090       };
17091     } catch (Dali::DaliException e) {
17092       {
17093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17094       };
17095     } catch (...) {
17096       {
17097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17098       };
17099     }
17100   }
17101
17102   jresult = (void *)result;
17103   return jresult;
17104 }
17105
17106
17107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17108   void * jresult ;
17109   std::string *arg1 = 0 ;
17110   Dali::Property::Value *result = 0 ;
17111
17112   if (!jarg1) {
17113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17114     return 0;
17115   }
17116   std::string arg1_str(jarg1);
17117   arg1 = &arg1_str;
17118   {
17119     try {
17120       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17121     } catch (std::out_of_range& e) {
17122       {
17123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17124       };
17125     } catch (std::exception& e) {
17126       {
17127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17128       };
17129     } catch (Dali::DaliException e) {
17130       {
17131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17132       };
17133     } catch (...) {
17134       {
17135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17136       };
17137     }
17138   }
17139
17140   jresult = (void *)result;
17141
17142   //argout typemap for const std::string&
17143
17144   return jresult;
17145 }
17146
17147
17148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17149   void * jresult ;
17150   Dali::Property::Array *arg1 = 0 ;
17151   Dali::Property::Value *result = 0 ;
17152
17153   arg1 = (Dali::Property::Array *)jarg1;
17154   if (!arg1) {
17155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17156     return 0;
17157   }
17158   {
17159     try {
17160       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17161     } catch (std::out_of_range& e) {
17162       {
17163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17164       };
17165     } catch (std::exception& e) {
17166       {
17167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17168       };
17169     } catch (Dali::DaliException e) {
17170       {
17171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17172       };
17173     } catch (...) {
17174       {
17175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17176       };
17177     }
17178   }
17179
17180   jresult = (void *)result;
17181   return jresult;
17182 }
17183
17184
17185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17186   void * jresult ;
17187   Dali::Property::Map *arg1 = 0 ;
17188   Dali::Property::Value *result = 0 ;
17189
17190   arg1 = (Dali::Property::Map *)jarg1;
17191   if (!arg1) {
17192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17193     return 0;
17194   }
17195   {
17196     try {
17197       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17198     } catch (std::out_of_range& e) {
17199       {
17200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17201       };
17202     } catch (std::exception& e) {
17203       {
17204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17205       };
17206     } catch (Dali::DaliException e) {
17207       {
17208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17209       };
17210     } catch (...) {
17211       {
17212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17213       };
17214     }
17215   }
17216
17217   jresult = (void *)result;
17218   return jresult;
17219 }
17220
17221
17222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17223   void * jresult ;
17224   Extents *arg1 = 0 ;
17225   Dali::Property::Value *result = 0 ;
17226
17227   arg1 = (Extents *)jarg1;
17228   if (!arg1) {
17229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17230     return 0;
17231   }
17232   {
17233     try {
17234       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17235     } catch (std::out_of_range& e) {
17236       {
17237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17238       };
17239     } catch (std::exception& e) {
17240       {
17241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17242       };
17243     } catch (...) {
17244       {
17245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17246       };
17247     }
17248   }
17249   jresult = (void *)result;
17250   return jresult;
17251 }
17252
17253
17254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17255   void * jresult ;
17256   Dali::Property::Type arg1 ;
17257   Dali::Property::Value *result = 0 ;
17258
17259   arg1 = (Dali::Property::Type)jarg1;
17260   {
17261     try {
17262       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17263     } catch (std::out_of_range& e) {
17264       {
17265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17266       };
17267     } catch (std::exception& e) {
17268       {
17269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17270       };
17271     } catch (Dali::DaliException e) {
17272       {
17273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17274       };
17275     } catch (...) {
17276       {
17277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17278       };
17279     }
17280   }
17281
17282   jresult = (void *)result;
17283   return jresult;
17284 }
17285
17286
17287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17288   void * jresult ;
17289   Dali::Property::Value *arg1 = 0 ;
17290   Dali::Property::Value *result = 0 ;
17291
17292   arg1 = (Dali::Property::Value *)jarg1;
17293   if (!arg1) {
17294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17295     return 0;
17296   }
17297   {
17298     try {
17299       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17300     } catch (std::out_of_range& e) {
17301       {
17302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17303       };
17304     } catch (std::exception& e) {
17305       {
17306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17307       };
17308     } catch (Dali::DaliException e) {
17309       {
17310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17311       };
17312     } catch (...) {
17313       {
17314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17315       };
17316     }
17317   }
17318
17319   jresult = (void *)result;
17320   return jresult;
17321 }
17322
17323
17324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17325   void * jresult ;
17326   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17327   Dali::Property::Value *arg2 = 0 ;
17328   Dali::Property::Value *result = 0 ;
17329
17330   arg1 = (Dali::Property::Value *)jarg1;
17331   arg2 = (Dali::Property::Value *)jarg2;
17332   if (!arg2) {
17333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17334     return 0;
17335   }
17336   {
17337     try {
17338       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17339     } catch (std::out_of_range& e) {
17340       {
17341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17342       };
17343     } catch (std::exception& e) {
17344       {
17345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17346       };
17347     } catch (Dali::DaliException e) {
17348       {
17349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17350       };
17351     } catch (...) {
17352       {
17353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17354       };
17355     }
17356   }
17357
17358   jresult = (void *)result;
17359   return jresult;
17360 }
17361
17362
17363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17364   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17365
17366   arg1 = (Dali::Property::Value *)jarg1;
17367   {
17368     try {
17369       delete arg1;
17370     } catch (std::out_of_range& e) {
17371       {
17372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17373       };
17374     } catch (std::exception& e) {
17375       {
17376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17377       };
17378     } catch (Dali::DaliException e) {
17379       {
17380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17381       };
17382     } catch (...) {
17383       {
17384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17385       };
17386     }
17387   }
17388
17389 }
17390
17391
17392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17393   int jresult ;
17394   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17395   Dali::Property::Type result;
17396
17397   arg1 = (Dali::Property::Value *)jarg1;
17398   {
17399     try {
17400       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17401     } catch (std::out_of_range& e) {
17402       {
17403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17404       };
17405     } catch (std::exception& e) {
17406       {
17407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17408       };
17409     } catch (Dali::DaliException e) {
17410       {
17411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17412       };
17413     } catch (...) {
17414       {
17415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17416       };
17417     }
17418   }
17419
17420   jresult = (int)result;
17421   return jresult;
17422 }
17423
17424
17425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17426   unsigned int jresult ;
17427   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17428   bool *arg2 = 0 ;
17429   bool result;
17430
17431   arg1 = (Dali::Property::Value *)jarg1;
17432   arg2 = (bool *)jarg2;
17433   {
17434     try {
17435       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17436     } catch (std::out_of_range& e) {
17437       {
17438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17439       };
17440     } catch (std::exception& e) {
17441       {
17442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17443       };
17444     } catch (Dali::DaliException e) {
17445       {
17446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17447       };
17448     } catch (...) {
17449       {
17450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17451       };
17452     }
17453   }
17454
17455   jresult = result;
17456   return jresult;
17457 }
17458
17459
17460 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17461   unsigned int jresult ;
17462   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17463   float *arg2 = 0 ;
17464   bool result;
17465
17466   arg1 = (Dali::Property::Value *)jarg1;
17467   arg2 = (float *)jarg2;
17468   {
17469     try {
17470       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17471     } catch (std::out_of_range& e) {
17472       {
17473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17474       };
17475     } catch (std::exception& e) {
17476       {
17477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17478       };
17479     } catch (Dali::DaliException e) {
17480       {
17481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17482       };
17483     } catch (...) {
17484       {
17485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17486       };
17487     }
17488   }
17489
17490   jresult = result;
17491   return jresult;
17492 }
17493
17494
17495 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17496   unsigned int jresult ;
17497   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17498   int *arg2 = 0 ;
17499   bool result;
17500
17501   arg1 = (Dali::Property::Value *)jarg1;
17502   arg2 = (int *)jarg2;
17503   {
17504     try {
17505       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17506     } catch (std::out_of_range& e) {
17507       {
17508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17509       };
17510     } catch (std::exception& e) {
17511       {
17512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17513       };
17514     } catch (Dali::DaliException e) {
17515       {
17516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17517       };
17518     } catch (...) {
17519       {
17520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17521       };
17522     }
17523   }
17524
17525   jresult = result;
17526   return jresult;
17527 }
17528
17529
17530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17531   unsigned int jresult ;
17532   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17533   Dali::Rect< int > *arg2 = 0 ;
17534   bool result;
17535
17536   arg1 = (Dali::Property::Value *)jarg1;
17537   arg2 = (Dali::Rect< int > *)jarg2;
17538   if (!arg2) {
17539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17540     return 0;
17541   }
17542   {
17543     try {
17544       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17545     } catch (std::out_of_range& e) {
17546       {
17547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17548       };
17549     } catch (std::exception& e) {
17550       {
17551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17552       };
17553     } catch (Dali::DaliException e) {
17554       {
17555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17556       };
17557     } catch (...) {
17558       {
17559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17560       };
17561     }
17562   }
17563
17564   jresult = result;
17565   return jresult;
17566 }
17567
17568
17569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17570   unsigned int jresult ;
17571   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17572   Dali::Vector2 *arg2 = 0 ;
17573   bool result;
17574
17575   arg1 = (Dali::Property::Value *)jarg1;
17576   arg2 = (Dali::Vector2 *)jarg2;
17577   if (!arg2) {
17578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17579     return 0;
17580   }
17581   {
17582     try {
17583       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17584     } catch (std::out_of_range& e) {
17585       {
17586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17587       };
17588     } catch (std::exception& e) {
17589       {
17590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17591       };
17592     } catch (Dali::DaliException e) {
17593       {
17594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17595       };
17596     } catch (...) {
17597       {
17598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17599       };
17600     }
17601   }
17602
17603   jresult = result;
17604   return jresult;
17605 }
17606
17607
17608 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17609   unsigned int jresult ;
17610   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17611   Dali::Vector3 *arg2 = 0 ;
17612   bool result;
17613
17614   arg1 = (Dali::Property::Value *)jarg1;
17615   arg2 = (Dali::Vector3 *)jarg2;
17616   if (!arg2) {
17617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17618     return 0;
17619   }
17620   {
17621     try {
17622       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17623     } catch (std::out_of_range& e) {
17624       {
17625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17626       };
17627     } catch (std::exception& e) {
17628       {
17629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17630       };
17631     } catch (Dali::DaliException e) {
17632       {
17633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17634       };
17635     } catch (...) {
17636       {
17637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17638       };
17639     }
17640   }
17641
17642   jresult = result;
17643   return jresult;
17644 }
17645
17646
17647 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17648   unsigned int jresult ;
17649   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17650   Dali::Vector4 *arg2 = 0 ;
17651   bool result;
17652
17653   arg1 = (Dali::Property::Value *)jarg1;
17654   arg2 = (Dali::Vector4 *)jarg2;
17655   if (!arg2) {
17656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17657     return 0;
17658   }
17659   {
17660     try {
17661       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17662     } catch (std::out_of_range& e) {
17663       {
17664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17665       };
17666     } catch (std::exception& e) {
17667       {
17668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17669       };
17670     } catch (Dali::DaliException e) {
17671       {
17672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17673       };
17674     } catch (...) {
17675       {
17676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17677       };
17678     }
17679   }
17680
17681   jresult = result;
17682   return jresult;
17683 }
17684
17685
17686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17687   unsigned int jresult ;
17688   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17689   Dali::Matrix3 *arg2 = 0 ;
17690   bool result;
17691
17692   arg1 = (Dali::Property::Value *)jarg1;
17693   arg2 = (Dali::Matrix3 *)jarg2;
17694   if (!arg2) {
17695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17696     return 0;
17697   }
17698   {
17699     try {
17700       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17701     } catch (std::out_of_range& e) {
17702       {
17703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17704       };
17705     } catch (std::exception& e) {
17706       {
17707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17708       };
17709     } catch (Dali::DaliException e) {
17710       {
17711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17712       };
17713     } catch (...) {
17714       {
17715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17716       };
17717     }
17718   }
17719
17720   jresult = result;
17721   return jresult;
17722 }
17723
17724
17725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17726   unsigned int jresult ;
17727   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17728   Dali::Matrix *arg2 = 0 ;
17729   bool result;
17730
17731   arg1 = (Dali::Property::Value *)jarg1;
17732   arg2 = (Dali::Matrix *)jarg2;
17733   if (!arg2) {
17734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17735     return 0;
17736   }
17737   {
17738     try {
17739       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17740     } catch (std::out_of_range& e) {
17741       {
17742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17743       };
17744     } catch (std::exception& e) {
17745       {
17746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17747       };
17748     } catch (Dali::DaliException e) {
17749       {
17750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17751       };
17752     } catch (...) {
17753       {
17754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17755       };
17756     }
17757   }
17758
17759   jresult = result;
17760   return jresult;
17761 }
17762
17763
17764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17765   unsigned int jresult ;
17766   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17767   Dali::AngleAxis *arg2 = 0 ;
17768   bool result;
17769
17770   arg1 = (Dali::Property::Value *)jarg1;
17771   arg2 = (Dali::AngleAxis *)jarg2;
17772   if (!arg2) {
17773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17774     return 0;
17775   }
17776   {
17777     try {
17778       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17779     } catch (std::out_of_range& e) {
17780       {
17781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17782       };
17783     } catch (std::exception& e) {
17784       {
17785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17786       };
17787     } catch (Dali::DaliException e) {
17788       {
17789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17790       };
17791     } catch (...) {
17792       {
17793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17794       };
17795     }
17796   }
17797
17798   jresult = result;
17799   return jresult;
17800 }
17801
17802
17803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17804   unsigned int jresult ;
17805   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17806   Dali::Quaternion *arg2 = 0 ;
17807   bool result;
17808
17809   arg1 = (Dali::Property::Value *)jarg1;
17810   arg2 = (Dali::Quaternion *)jarg2;
17811   if (!arg2) {
17812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17813     return 0;
17814   }
17815   {
17816     try {
17817       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17818     } catch (std::out_of_range& e) {
17819       {
17820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17821       };
17822     } catch (std::exception& e) {
17823       {
17824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17825       };
17826     } catch (Dali::DaliException e) {
17827       {
17828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17829       };
17830     } catch (...) {
17831       {
17832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17833       };
17834     }
17835   }
17836
17837   jresult = result;
17838   return jresult;
17839 }
17840
17841
17842 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17843   unsigned int jresult ;
17844   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17845   std::string *arg2 = 0 ;
17846   bool result;
17847
17848   arg1 = (Dali::Property::Value *)jarg1;
17849
17850   //typemap in
17851   std::string temp;
17852   arg2 = &temp;
17853
17854   {
17855     try {
17856       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17857     } catch (std::out_of_range& e) {
17858       {
17859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17860       };
17861     } catch (std::exception& e) {
17862       {
17863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17864       };
17865     } catch (Dali::DaliException e) {
17866       {
17867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17868       };
17869     } catch (...) {
17870       {
17871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17872       };
17873     }
17874   }
17875
17876   jresult = result;
17877
17878   //Typemap argout in c++ file.
17879   //This will convert c++ string to c# string
17880   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17881
17882   return jresult;
17883 }
17884
17885
17886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17887   unsigned int jresult ;
17888   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17889   Dali::Property::Array *arg2 = 0 ;
17890   bool result;
17891
17892   arg1 = (Dali::Property::Value *)jarg1;
17893   arg2 = (Dali::Property::Array *)jarg2;
17894   if (!arg2) {
17895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17896     return 0;
17897   }
17898   {
17899     try {
17900       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17901     } catch (std::out_of_range& e) {
17902       {
17903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17904       };
17905     } catch (std::exception& e) {
17906       {
17907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17908       };
17909     } catch (Dali::DaliException e) {
17910       {
17911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17912       };
17913     } catch (...) {
17914       {
17915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17916       };
17917     }
17918   }
17919
17920   jresult = result;
17921   return jresult;
17922 }
17923
17924
17925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17926   unsigned int jresult ;
17927   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17928   Dali::Property::Map *arg2 = 0 ;
17929   bool result;
17930
17931   arg1 = (Dali::Property::Value *)jarg1;
17932   arg2 = (Dali::Property::Map *)jarg2;
17933   if (!arg2) {
17934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17935     return 0;
17936   }
17937   {
17938     try {
17939       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17940     } catch (std::out_of_range& e) {
17941       {
17942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17943       };
17944     } catch (std::exception& e) {
17945       {
17946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17947       };
17948     } catch (Dali::DaliException e) {
17949       {
17950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17951       };
17952     } catch (...) {
17953       {
17954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17955       };
17956     }
17957   }
17958
17959   jresult = result;
17960   return jresult;
17961 }
17962
17963
17964 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17965   unsigned int jresult ;
17966   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17967   Extents *arg2 = 0 ;
17968   bool result;
17969
17970   arg1 = (Dali::Property::Value *)jarg1;
17971   arg2 = (Extents *)jarg2;
17972   if (!arg2) {
17973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17974     return 0;
17975   }
17976   {
17977     try {
17978       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17979     } catch (std::out_of_range& e) {
17980       {
17981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17982       };
17983     } catch (std::exception& e) {
17984       {
17985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17986       };
17987     } catch (...) {
17988       {
17989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17990       };
17991     }
17992   }
17993   jresult = result;
17994   return jresult;
17995 }
17996
17997
17998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17999   void * jresult ;
18000   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18001   Dali::Property::Array *result = 0 ;
18002
18003   arg1 = (Dali::Property::Value *)jarg1;
18004   {
18005     try {
18006       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
18007     } catch (std::out_of_range& e) {
18008       {
18009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18010       };
18011     } catch (std::exception& e) {
18012       {
18013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18014       };
18015     } catch (Dali::DaliException e) {
18016       {
18017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18018       };
18019     } catch (...) {
18020       {
18021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18022       };
18023     }
18024   }
18025
18026   jresult = (void *)result;
18027   return jresult;
18028 }
18029
18030
18031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
18032   void * jresult ;
18033   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18034   Dali::Property::Map *result = 0 ;
18035
18036   arg1 = (Dali::Property::Value *)jarg1;
18037   {
18038     try {
18039       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18040     } catch (std::out_of_range& e) {
18041       {
18042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18043       };
18044     } catch (std::exception& e) {
18045       {
18046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18047       };
18048     } catch (Dali::DaliException e) {
18049       {
18050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18051       };
18052     } catch (...) {
18053       {
18054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18055       };
18056     }
18057   }
18058
18059   jresult = (void *)result;
18060   return jresult;
18061 }
18062
18063
18064 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18065   char * jresult ;
18066   Dali::Property::Type arg1 ;
18067   char *result = 0 ;
18068
18069   arg1 = (Dali::Property::Type)jarg1;
18070   {
18071     try {
18072       result = (char *)Dali::PropertyTypes::GetName(arg1);
18073     } catch (std::out_of_range& e) {
18074       {
18075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18076       };
18077     } catch (std::exception& e) {
18078       {
18079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18080       };
18081     } catch (Dali::DaliException e) {
18082       {
18083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18084       };
18085     } catch (...) {
18086       {
18087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18088       };
18089     }
18090   }
18091
18092   jresult = SWIG_csharp_string_callback((const char *)result);
18093   return jresult;
18094 }
18095
18096
18097 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18098   unsigned int jresult ;
18099   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18100   std::string *arg2 = 0 ;
18101   Dali::Property::Map *arg3 = 0 ;
18102   bool result;
18103
18104   arg1 = (Dali::BaseObject *)jarg1;
18105   if (!jarg2) {
18106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18107     return 0;
18108   }
18109   std::string arg2_str(jarg2);
18110   arg2 = &arg2_str;
18111   arg3 = (Dali::Property::Map *)jarg3;
18112   if (!arg3) {
18113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18114     return 0;
18115   }
18116   {
18117     try {
18118       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18119     } catch (std::out_of_range& e) {
18120       {
18121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18122       };
18123     } catch (std::exception& e) {
18124       {
18125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18126       };
18127     } catch (Dali::DaliException e) {
18128       {
18129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18130       };
18131     } catch (...) {
18132       {
18133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18134       };
18135     }
18136   }
18137
18138   jresult = result;
18139
18140   //argout typemap for const std::string&
18141
18142   return jresult;
18143 }
18144
18145
18146 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18147   char * jresult ;
18148   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18149   std::string *result = 0 ;
18150
18151   arg1 = (Dali::BaseObject *)jarg1;
18152   {
18153     try {
18154       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18155     } catch (std::out_of_range& e) {
18156       {
18157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18158       };
18159     } catch (std::exception& e) {
18160       {
18161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18162       };
18163     } catch (Dali::DaliException e) {
18164       {
18165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18166       };
18167     } catch (...) {
18168       {
18169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18170       };
18171     }
18172   }
18173
18174   jresult = SWIG_csharp_string_callback(result->c_str());
18175   return jresult;
18176 }
18177
18178
18179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18180   unsigned int jresult ;
18181   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18182   Dali::TypeInfo *arg2 = 0 ;
18183   bool result;
18184
18185   arg1 = (Dali::BaseObject *)jarg1;
18186   arg2 = (Dali::TypeInfo *)jarg2;
18187   if (!arg2) {
18188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18189     return 0;
18190   }
18191   {
18192     try {
18193       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18194     } catch (std::out_of_range& e) {
18195       {
18196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18197       };
18198     } catch (std::exception& e) {
18199       {
18200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18201       };
18202     } catch (Dali::DaliException e) {
18203       {
18204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18205       };
18206     } catch (...) {
18207       {
18208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18209       };
18210     }
18211   }
18212
18213   jresult = result;
18214   return jresult;
18215 }
18216
18217
18218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18219   unsigned int jresult ;
18220   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18221   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18222   std::string *arg3 = 0 ;
18223   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18224   bool result;
18225
18226   arg1 = (Dali::BaseObject *)jarg1;
18227   arg2 = (ConnectionTrackerInterface *)jarg2;
18228   if (!jarg3) {
18229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18230     return 0;
18231   }
18232   std::string arg3_str(jarg3);
18233   arg3 = &arg3_str;
18234   arg4 = (FunctorDelegate *)jarg4;
18235   {
18236     try {
18237       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18238     } catch (std::out_of_range& e) {
18239       {
18240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18241       };
18242     } catch (std::exception& e) {
18243       {
18244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18245       };
18246     } catch (Dali::DaliException e) {
18247       {
18248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18249       };
18250     } catch (...) {
18251       {
18252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18253       };
18254     }
18255   }
18256
18257   jresult = result;
18258
18259   //argout typemap for const std::string&
18260
18261   return jresult;
18262 }
18263
18264
18265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18266   void * jresult ;
18267   Dali::BaseHandle *arg1 = 0 ;
18268   Dali::BaseObject *result = 0 ;
18269
18270   arg1 = (Dali::BaseHandle *)jarg1;
18271   if (!arg1) {
18272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18273     return 0;
18274   }
18275   {
18276     try {
18277       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18278     } catch (std::out_of_range& e) {
18279       {
18280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18281       };
18282     } catch (std::exception& e) {
18283       {
18284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18285       };
18286     } catch (Dali::DaliException e) {
18287       {
18288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18289       };
18290     } catch (...) {
18291       {
18292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18293       };
18294     }
18295   }
18296
18297   jresult = (void *)result;
18298   return jresult;
18299 }
18300
18301
18302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18303   void * jresult ;
18304   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18305   Dali::BaseHandle *result = 0 ;
18306
18307   arg1 = (Dali::BaseObject *)jarg1;
18308   {
18309     try {
18310       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18311     } catch (std::out_of_range& e) {
18312       {
18313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18314       };
18315     } catch (std::exception& e) {
18316       {
18317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18318       };
18319     } catch (Dali::DaliException e) {
18320       {
18321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18322       };
18323     } catch (...) {
18324       {
18325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18326       };
18327     }
18328   }
18329
18330   jresult = (void *)result;
18331   return jresult;
18332 }
18333
18334
18335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18336   void * jresult ;
18337   Dali::BaseHandle *result = 0 ;
18338
18339   {
18340     try {
18341       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18342     } catch (std::out_of_range& e) {
18343       {
18344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18345       };
18346     } catch (std::exception& e) {
18347       {
18348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18349       };
18350     } catch (Dali::DaliException e) {
18351       {
18352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18353       };
18354     } catch (...) {
18355       {
18356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18357       };
18358     }
18359   }
18360
18361   jresult = (void *)result;
18362   return jresult;
18363 }
18364
18365
18366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18367   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18368
18369   arg1 = (Dali::BaseHandle *)jarg1;
18370   {
18371     try {
18372       delete arg1;
18373     } catch (std::out_of_range& e) {
18374       {
18375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18376       };
18377     } catch (std::exception& e) {
18378       {
18379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18380       };
18381     } catch (Dali::DaliException e) {
18382       {
18383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18384       };
18385     } catch (...) {
18386       {
18387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18388       };
18389     }
18390   }
18391
18392 }
18393
18394
18395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18396   void * jresult ;
18397   Dali::BaseHandle *arg1 = 0 ;
18398   Dali::BaseHandle *result = 0 ;
18399
18400   arg1 = (Dali::BaseHandle *)jarg1;
18401   if (!arg1) {
18402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18403     return 0;
18404   }
18405   {
18406     try {
18407       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18408     } catch (std::out_of_range& e) {
18409       {
18410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18411       };
18412     } catch (std::exception& e) {
18413       {
18414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18415       };
18416     } catch (Dali::DaliException e) {
18417       {
18418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18419       };
18420     } catch (...) {
18421       {
18422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18423       };
18424     }
18425   }
18426
18427   jresult = (void *)result;
18428   return jresult;
18429 }
18430
18431
18432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18433   void * jresult ;
18434   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18435   Dali::BaseHandle *arg2 = 0 ;
18436   Dali::BaseHandle *result = 0 ;
18437
18438   arg1 = (Dali::BaseHandle *)jarg1;
18439   arg2 = (Dali::BaseHandle *)jarg2;
18440   if (!arg2) {
18441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18442     return 0;
18443   }
18444   {
18445     try {
18446       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18447     } catch (std::out_of_range& e) {
18448       {
18449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18450       };
18451     } catch (std::exception& e) {
18452       {
18453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18454       };
18455     } catch (Dali::DaliException e) {
18456       {
18457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18458       };
18459     } catch (...) {
18460       {
18461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18462       };
18463     }
18464   }
18465
18466   jresult = (void *)result;
18467   return jresult;
18468 }
18469
18470
18471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18472   unsigned int jresult ;
18473   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18474   std::string *arg2 = 0 ;
18475   Dali::Property::Map *arg3 = 0 ;
18476   bool result;
18477
18478   arg1 = (Dali::BaseHandle *)jarg1;
18479   if (!jarg2) {
18480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18481     return 0;
18482   }
18483   std::string arg2_str(jarg2);
18484   arg2 = &arg2_str;
18485   arg3 = (Dali::Property::Map *)jarg3;
18486   if (!arg3) {
18487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18488     return 0;
18489   }
18490   {
18491     try {
18492       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18493     } catch (std::out_of_range& e) {
18494       {
18495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18496       };
18497     } catch (std::exception& e) {
18498       {
18499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18500       };
18501     } catch (Dali::DaliException e) {
18502       {
18503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18504       };
18505     } catch (...) {
18506       {
18507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18508       };
18509     }
18510   }
18511
18512   jresult = result;
18513
18514   //argout typemap for const std::string&
18515
18516   return jresult;
18517 }
18518
18519
18520 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18521   char * jresult ;
18522   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18523   std::string *result = 0 ;
18524
18525   arg1 = (Dali::BaseHandle *)jarg1;
18526   {
18527     try {
18528       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18529     } catch (std::out_of_range& e) {
18530       {
18531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18532       };
18533     } catch (std::exception& e) {
18534       {
18535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18536       };
18537     } catch (Dali::DaliException e) {
18538       {
18539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18540       };
18541     } catch (...) {
18542       {
18543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18544       };
18545     }
18546   }
18547
18548   jresult = SWIG_csharp_string_callback(result->c_str());
18549   return jresult;
18550 }
18551
18552
18553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18554   unsigned int jresult ;
18555   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18556   Dali::TypeInfo *arg2 = 0 ;
18557   bool result;
18558
18559   arg1 = (Dali::BaseHandle *)jarg1;
18560   arg2 = (Dali::TypeInfo *)jarg2;
18561   if (!arg2) {
18562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18563     return 0;
18564   }
18565   {
18566     try {
18567       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18568     } catch (std::out_of_range& e) {
18569       {
18570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18571       };
18572     } catch (std::exception& e) {
18573       {
18574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18575       };
18576     } catch (Dali::DaliException e) {
18577       {
18578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18579       };
18580     } catch (...) {
18581       {
18582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18583       };
18584     }
18585   }
18586
18587   jresult = result;
18588   return jresult;
18589 }
18590
18591
18592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18593   void * jresult ;
18594   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18595   Dali::BaseObject *result = 0 ;
18596
18597   arg1 = (Dali::BaseHandle *)jarg1;
18598   {
18599     try {
18600       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18601     } catch (std::out_of_range& e) {
18602       {
18603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18604       };
18605     } catch (std::exception& e) {
18606       {
18607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18608       };
18609     } catch (Dali::DaliException e) {
18610       {
18611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18612       };
18613     } catch (...) {
18614       {
18615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18616       };
18617     }
18618   }
18619
18620   jresult = (void *)result;
18621   return jresult;
18622 }
18623
18624
18625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18626   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18627
18628   arg1 = (Dali::BaseHandle *)jarg1;
18629   {
18630     try {
18631       (arg1)->Reset();
18632     } catch (std::out_of_range& e) {
18633       {
18634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18635       };
18636     } catch (std::exception& e) {
18637       {
18638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18639       };
18640     } catch (Dali::DaliException e) {
18641       {
18642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18643       };
18644     } catch (...) {
18645       {
18646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18647       };
18648     }
18649   }
18650
18651 }
18652
18653
18654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18655   unsigned int jresult ;
18656   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18657   Dali::BaseHandle *arg2 = 0 ;
18658   bool result;
18659
18660   arg1 = (Dali::BaseHandle *)jarg1;
18661   arg2 = (Dali::BaseHandle *)jarg2;
18662   if (!arg2) {
18663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18664     return 0;
18665   }
18666   {
18667     try {
18668       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18669     } catch (std::out_of_range& e) {
18670       {
18671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18672       };
18673     } catch (std::exception& e) {
18674       {
18675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18676       };
18677     } catch (Dali::DaliException e) {
18678       {
18679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18680       };
18681     } catch (...) {
18682       {
18683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18684       };
18685     }
18686   }
18687
18688   jresult = result;
18689   return jresult;
18690 }
18691
18692
18693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18694   unsigned int jresult ;
18695   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18696   Dali::BaseHandle *arg2 = 0 ;
18697   bool result;
18698
18699   arg1 = (Dali::BaseHandle *)jarg1;
18700   arg2 = (Dali::BaseHandle *)jarg2;
18701   if (!arg2) {
18702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18703     return 0;
18704   }
18705   {
18706     try {
18707       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18708     } catch (std::out_of_range& e) {
18709       {
18710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18711       };
18712     } catch (std::exception& e) {
18713       {
18714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18715       };
18716     } catch (Dali::DaliException e) {
18717       {
18718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18719       };
18720     } catch (...) {
18721       {
18722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18723       };
18724     }
18725   }
18726
18727   jresult = result;
18728   return jresult;
18729 }
18730
18731
18732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18733   void * jresult ;
18734   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18735   Dali::RefObject *result = 0 ;
18736
18737   arg1 = (Dali::BaseHandle *)jarg1;
18738   {
18739     try {
18740       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18741     } catch (std::out_of_range& e) {
18742       {
18743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18744       };
18745     } catch (std::exception& e) {
18746       {
18747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18748       };
18749     } catch (Dali::DaliException e) {
18750       {
18751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18752       };
18753     } catch (...) {
18754       {
18755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18756       };
18757     }
18758   }
18759
18760   jresult = (void *)result;
18761   return jresult;
18762 }
18763
18764
18765 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18766   unsigned int jresult ;
18767   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18768   bool result;
18769
18770   arg1 = (Dali::BaseHandle *)jarg1;
18771   {
18772     try {
18773       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18774     } catch (std::out_of_range& e) {
18775       {
18776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18777       };
18778     } catch (std::exception& e) {
18779       {
18780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18781       };
18782     } catch (Dali::DaliException e) {
18783       {
18784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18785       };
18786     } catch (...) {
18787       {
18788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18789       };
18790     }
18791   }
18792
18793   jresult = result;
18794   return jresult;
18795 }
18796
18797
18798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18799   unsigned int jresult ;
18800   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18801   Dali::BaseHandle *arg2 = 0 ;
18802   bool result;
18803
18804   arg1 = (Dali::BaseHandle *)jarg1;
18805   arg2 = (Dali::BaseHandle *)jarg2;
18806   if (!arg2) {
18807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18808     return 0;
18809   }
18810   {
18811     try {
18812       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18813     } catch (std::out_of_range& e) {
18814       {
18815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18816       };
18817     } catch (std::exception& e) {
18818       {
18819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18820       };
18821     } catch (Dali::DaliException e) {
18822       {
18823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18824       };
18825     } catch (...) {
18826       {
18827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18828       };
18829     }
18830   }
18831
18832   jresult = result;
18833   return jresult;
18834 }
18835
18836
18837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18838   unsigned int jresult ;
18839   Dali::BaseHandle *arg1 = 0 ;
18840   Dali::BaseHandle *arg2 = 0 ;
18841   bool result;
18842
18843   arg1 = (Dali::BaseHandle *)jarg1;
18844   if (!arg1) {
18845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18846     return 0;
18847   }
18848   arg2 = (Dali::BaseHandle *)jarg2;
18849   if (!arg2) {
18850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18851     return 0;
18852   }
18853   {
18854     try {
18855       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18856     } catch (std::out_of_range& e) {
18857       {
18858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18859       };
18860     } catch (std::exception& e) {
18861       {
18862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18863       };
18864     } catch (Dali::DaliException e) {
18865       {
18866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18867       };
18868     } catch (...) {
18869       {
18870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18871       };
18872     }
18873   }
18874
18875   jresult = result;
18876   return jresult;
18877 }
18878
18879
18880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18881   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18882
18883   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18884   {
18885     try {
18886       delete arg1;
18887     } catch (std::out_of_range& e) {
18888       {
18889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18890       };
18891     } catch (std::exception& e) {
18892       {
18893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18894       };
18895     } catch (Dali::DaliException e) {
18896       {
18897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18898       };
18899     } catch (...) {
18900       {
18901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18902       };
18903     }
18904   }
18905
18906 }
18907
18908
18909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18910   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18911   SlotObserver *arg2 = (SlotObserver *) 0 ;
18912   CallbackBase *arg3 = (CallbackBase *) 0 ;
18913
18914   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18915   arg2 = (SlotObserver *)jarg2;
18916   arg3 = (CallbackBase *)jarg3;
18917   {
18918     try {
18919       (arg1)->SignalConnected(arg2,arg3);
18920     } catch (std::out_of_range& e) {
18921       {
18922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18923       };
18924     } catch (std::exception& e) {
18925       {
18926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18927       };
18928     } catch (Dali::DaliException e) {
18929       {
18930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18931       };
18932     } catch (...) {
18933       {
18934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18935       };
18936     }
18937   }
18938
18939 }
18940
18941
18942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18943   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18944
18945   arg1 = (Dali::SignalObserver *)jarg1;
18946   {
18947     try {
18948       delete arg1;
18949     } catch (std::out_of_range& e) {
18950       {
18951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18952       };
18953     } catch (std::exception& e) {
18954       {
18955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18956       };
18957     } catch (Dali::DaliException e) {
18958       {
18959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18960       };
18961     } catch (...) {
18962       {
18963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18964       };
18965     }
18966   }
18967
18968 }
18969
18970
18971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18972   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18973   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18974   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18975
18976   arg1 = (Dali::SignalObserver *)jarg1;
18977   arg2 = (Dali::SlotObserver *)jarg2;
18978   arg3 = (Dali::CallbackBase *)jarg3;
18979   {
18980     try {
18981       (arg1)->SignalDisconnected(arg2,arg3);
18982     } catch (std::out_of_range& e) {
18983       {
18984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18985       };
18986     } catch (std::exception& e) {
18987       {
18988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18989       };
18990     } catch (Dali::DaliException e) {
18991       {
18992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18993       };
18994     } catch (...) {
18995       {
18996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18997       };
18998     }
18999   }
19000
19001 }
19002
19003
19004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
19005   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19006
19007   arg1 = (Dali::SlotObserver *)jarg1;
19008   {
19009     try {
19010       delete arg1;
19011     } catch (std::out_of_range& e) {
19012       {
19013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19014       };
19015     } catch (std::exception& e) {
19016       {
19017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19018       };
19019     } catch (Dali::DaliException e) {
19020       {
19021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19022       };
19023     } catch (...) {
19024       {
19025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19026       };
19027     }
19028   }
19029
19030 }
19031
19032
19033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
19034   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19035   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19036
19037   arg1 = (Dali::SlotObserver *)jarg1;
19038   arg2 = (Dali::CallbackBase *)jarg2;
19039   {
19040     try {
19041       (arg1)->SlotDisconnected(arg2);
19042     } catch (std::out_of_range& e) {
19043       {
19044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19045       };
19046     } catch (std::exception& e) {
19047       {
19048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19049       };
19050     } catch (Dali::DaliException e) {
19051       {
19052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19053       };
19054     } catch (...) {
19055       {
19056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19057       };
19058     }
19059   }
19060
19061 }
19062
19063
19064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19065   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19066
19067   arg1 = (Dali::ConnectionTracker *)jarg1;
19068   {
19069     try {
19070       delete arg1;
19071     } catch (std::out_of_range& e) {
19072       {
19073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19074       };
19075     } catch (std::exception& e) {
19076       {
19077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19078       };
19079     } catch (Dali::DaliException e) {
19080       {
19081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19082       };
19083     } catch (...) {
19084       {
19085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19086       };
19087     }
19088   }
19089
19090 }
19091
19092
19093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19094   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19095
19096   arg1 = (Dali::ConnectionTracker *)jarg1;
19097   {
19098     try {
19099       (arg1)->DisconnectAll();
19100     } catch (std::out_of_range& e) {
19101       {
19102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19103       };
19104     } catch (std::exception& e) {
19105       {
19106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19107       };
19108     } catch (Dali::DaliException e) {
19109       {
19110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19111       };
19112     } catch (...) {
19113       {
19114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19115       };
19116     }
19117   }
19118
19119 }
19120
19121
19122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19123   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19124   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19125   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19126
19127   arg1 = (Dali::ConnectionTracker *)jarg1;
19128   arg2 = (Dali::SlotObserver *)jarg2;
19129   arg3 = (Dali::CallbackBase *)jarg3;
19130   {
19131     try {
19132       (arg1)->SignalConnected(arg2,arg3);
19133     } catch (std::out_of_range& e) {
19134       {
19135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19136       };
19137     } catch (std::exception& e) {
19138       {
19139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19140       };
19141     } catch (Dali::DaliException e) {
19142       {
19143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19144       };
19145     } catch (...) {
19146       {
19147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19148       };
19149     }
19150   }
19151
19152 }
19153
19154
19155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19156   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19157   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19158   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19159
19160   arg1 = (Dali::ConnectionTracker *)jarg1;
19161   arg2 = (Dali::SlotObserver *)jarg2;
19162   arg3 = (Dali::CallbackBase *)jarg3;
19163   {
19164     try {
19165       (arg1)->SignalDisconnected(arg2,arg3);
19166     } catch (std::out_of_range& e) {
19167       {
19168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19169       };
19170     } catch (std::exception& e) {
19171       {
19172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19173       };
19174     } catch (Dali::DaliException e) {
19175       {
19176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19177       };
19178     } catch (...) {
19179       {
19180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19181       };
19182     }
19183   }
19184
19185 }
19186
19187
19188 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19189   unsigned long jresult ;
19190   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19191   std::size_t result;
19192
19193   arg1 = (Dali::ConnectionTracker *)jarg1;
19194   {
19195     try {
19196       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19197     } catch (std::out_of_range& e) {
19198       {
19199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19200       };
19201     } catch (std::exception& e) {
19202       {
19203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19204       };
19205     } catch (Dali::DaliException e) {
19206       {
19207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19208       };
19209     } catch (...) {
19210       {
19211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19212       };
19213     }
19214   }
19215
19216   jresult = (unsigned long)result;
19217   return jresult;
19218 }
19219
19220
19221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19222   void * jresult ;
19223   Dali::ObjectRegistry *result = 0 ;
19224
19225   {
19226     try {
19227       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19228     } catch (std::out_of_range& e) {
19229       {
19230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19231       };
19232     } catch (std::exception& e) {
19233       {
19234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19235       };
19236     } catch (Dali::DaliException e) {
19237       {
19238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19239       };
19240     } catch (...) {
19241       {
19242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19243       };
19244     }
19245   }
19246
19247   jresult = (void *)result;
19248   return jresult;
19249 }
19250
19251
19252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19253   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19254
19255   arg1 = (Dali::ObjectRegistry *)jarg1;
19256   {
19257     try {
19258       delete arg1;
19259     } catch (std::out_of_range& e) {
19260       {
19261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19262       };
19263     } catch (std::exception& e) {
19264       {
19265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19266       };
19267     } catch (Dali::DaliException e) {
19268       {
19269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19270       };
19271     } catch (...) {
19272       {
19273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19274       };
19275     }
19276   }
19277
19278 }
19279
19280
19281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19282   void * jresult ;
19283   Dali::ObjectRegistry *arg1 = 0 ;
19284   Dali::ObjectRegistry *result = 0 ;
19285
19286   arg1 = (Dali::ObjectRegistry *)jarg1;
19287   if (!arg1) {
19288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19289     return 0;
19290   }
19291   {
19292     try {
19293       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19294     } catch (std::out_of_range& e) {
19295       {
19296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19297       };
19298     } catch (std::exception& e) {
19299       {
19300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19301       };
19302     } catch (Dali::DaliException e) {
19303       {
19304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19305       };
19306     } catch (...) {
19307       {
19308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19309       };
19310     }
19311   }
19312
19313   jresult = (void *)result;
19314   return jresult;
19315 }
19316
19317
19318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19319   void * jresult ;
19320   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19321   Dali::ObjectRegistry *arg2 = 0 ;
19322   Dali::ObjectRegistry *result = 0 ;
19323
19324   arg1 = (Dali::ObjectRegistry *)jarg1;
19325   arg2 = (Dali::ObjectRegistry *)jarg2;
19326   if (!arg2) {
19327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19328     return 0;
19329   }
19330   {
19331     try {
19332       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19333     } catch (std::out_of_range& e) {
19334       {
19335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19336       };
19337     } catch (std::exception& e) {
19338       {
19339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19340       };
19341     } catch (Dali::DaliException e) {
19342       {
19343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19344       };
19345     } catch (...) {
19346       {
19347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19348       };
19349     }
19350   }
19351
19352   jresult = (void *)result;
19353   return jresult;
19354 }
19355
19356
19357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19358   void * jresult ;
19359   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19360   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19361
19362   arg1 = (Dali::ObjectRegistry *)jarg1;
19363   {
19364     try {
19365       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19366     } catch (std::out_of_range& e) {
19367       {
19368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19369       };
19370     } catch (std::exception& e) {
19371       {
19372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19373       };
19374     } catch (Dali::DaliException e) {
19375       {
19376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19377       };
19378     } catch (...) {
19379       {
19380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19381       };
19382     }
19383   }
19384
19385   jresult = (void *)result;
19386   return jresult;
19387 }
19388
19389
19390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19391   void * jresult ;
19392   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19393   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19394
19395   arg1 = (Dali::ObjectRegistry *)jarg1;
19396   {
19397     try {
19398       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19399     } catch (std::out_of_range& e) {
19400       {
19401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19402       };
19403     } catch (std::exception& e) {
19404       {
19405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19406       };
19407     } catch (Dali::DaliException e) {
19408       {
19409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19410       };
19411     } catch (...) {
19412       {
19413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19414       };
19415     }
19416   }
19417
19418   jresult = (void *)result;
19419   return jresult;
19420 }
19421
19422
19423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19424   void * jresult ;
19425   Dali::PropertyCondition *result = 0 ;
19426
19427   {
19428     try {
19429       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19430     } catch (std::out_of_range& e) {
19431       {
19432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19433       };
19434     } catch (std::exception& e) {
19435       {
19436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19437       };
19438     } catch (Dali::DaliException e) {
19439       {
19440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19441       };
19442     } catch (...) {
19443       {
19444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19445       };
19446     }
19447   }
19448
19449   jresult = (void *)result;
19450   return jresult;
19451 }
19452
19453
19454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19455   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19456
19457   arg1 = (Dali::PropertyCondition *)jarg1;
19458   {
19459     try {
19460       delete arg1;
19461     } catch (std::out_of_range& e) {
19462       {
19463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19464       };
19465     } catch (std::exception& e) {
19466       {
19467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19468       };
19469     } catch (Dali::DaliException e) {
19470       {
19471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19472       };
19473     } catch (...) {
19474       {
19475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19476       };
19477     }
19478   }
19479
19480 }
19481
19482
19483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19484   void * jresult ;
19485   Dali::PropertyCondition *arg1 = 0 ;
19486   Dali::PropertyCondition *result = 0 ;
19487
19488   arg1 = (Dali::PropertyCondition *)jarg1;
19489   if (!arg1) {
19490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19491     return 0;
19492   }
19493   {
19494     try {
19495       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19496     } catch (std::out_of_range& e) {
19497       {
19498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19499       };
19500     } catch (std::exception& e) {
19501       {
19502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19503       };
19504     } catch (Dali::DaliException e) {
19505       {
19506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19507       };
19508     } catch (...) {
19509       {
19510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19511       };
19512     }
19513   }
19514
19515   jresult = (void *)result;
19516   return jresult;
19517 }
19518
19519
19520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19521   void * jresult ;
19522   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19523   Dali::PropertyCondition *arg2 = 0 ;
19524   Dali::PropertyCondition *result = 0 ;
19525
19526   arg1 = (Dali::PropertyCondition *)jarg1;
19527   arg2 = (Dali::PropertyCondition *)jarg2;
19528   if (!arg2) {
19529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19530     return 0;
19531   }
19532   {
19533     try {
19534       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19535     } catch (std::out_of_range& e) {
19536       {
19537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19538       };
19539     } catch (std::exception& e) {
19540       {
19541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19542       };
19543     } catch (Dali::DaliException e) {
19544       {
19545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19546       };
19547     } catch (...) {
19548       {
19549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19550       };
19551     }
19552   }
19553
19554   jresult = (void *)result;
19555   return jresult;
19556 }
19557
19558
19559 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19560   unsigned long jresult ;
19561   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19562   std::size_t result;
19563
19564   arg1 = (Dali::PropertyCondition *)jarg1;
19565   {
19566     try {
19567       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19568     } catch (std::out_of_range& e) {
19569       {
19570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19571       };
19572     } catch (std::exception& e) {
19573       {
19574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19575       };
19576     } catch (...) {
19577       {
19578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19579       };
19580     }
19581   }
19582   jresult = (unsigned long)result;
19583   return jresult;
19584 }
19585
19586
19587 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19588   float jresult ;
19589   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19590   std::size_t arg2 ;
19591   float result;
19592
19593   arg1 = (Dali::PropertyCondition *)jarg1;
19594   arg2 = (std::size_t)jarg2;
19595   {
19596     try {
19597       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19598     } catch (std::out_of_range& e) {
19599       {
19600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19601       };
19602     } catch (std::exception& e) {
19603       {
19604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19605       };
19606     } catch (...) {
19607       {
19608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19609       };
19610     }
19611   }
19612   jresult = result;
19613   return jresult;
19614 }
19615
19616
19617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19618   void * jresult ;
19619   float arg1 ;
19620   Dali::PropertyCondition result;
19621
19622   arg1 = (float)jarg1;
19623   {
19624     try {
19625       result = Dali::LessThanCondition(arg1);
19626     } catch (std::out_of_range& e) {
19627       {
19628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19629       };
19630     } catch (std::exception& e) {
19631       {
19632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19633       };
19634     } catch (Dali::DaliException e) {
19635       {
19636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19637       };
19638     } catch (...) {
19639       {
19640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19641       };
19642     }
19643   }
19644
19645   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19646   return jresult;
19647 }
19648
19649
19650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19651   void * jresult ;
19652   float arg1 ;
19653   Dali::PropertyCondition result;
19654
19655   arg1 = (float)jarg1;
19656   {
19657     try {
19658       result = Dali::GreaterThanCondition(arg1);
19659     } catch (std::out_of_range& e) {
19660       {
19661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19662       };
19663     } catch (std::exception& e) {
19664       {
19665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19666       };
19667     } catch (Dali::DaliException e) {
19668       {
19669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19670       };
19671     } catch (...) {
19672       {
19673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19674       };
19675     }
19676   }
19677
19678   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19679   return jresult;
19680 }
19681
19682
19683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19684   void * jresult ;
19685   float arg1 ;
19686   float arg2 ;
19687   Dali::PropertyCondition result;
19688
19689   arg1 = (float)jarg1;
19690   arg2 = (float)jarg2;
19691   {
19692     try {
19693       result = Dali::InsideCondition(arg1,arg2);
19694     } catch (std::out_of_range& e) {
19695       {
19696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19697       };
19698     } catch (std::exception& e) {
19699       {
19700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19701       };
19702     } catch (Dali::DaliException e) {
19703       {
19704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19705       };
19706     } catch (...) {
19707       {
19708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19709       };
19710     }
19711   }
19712
19713   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19714   return jresult;
19715 }
19716
19717
19718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19719   void * jresult ;
19720   float arg1 ;
19721   float arg2 ;
19722   Dali::PropertyCondition result;
19723
19724   arg1 = (float)jarg1;
19725   arg2 = (float)jarg2;
19726   {
19727     try {
19728       result = Dali::OutsideCondition(arg1,arg2);
19729     } catch (std::out_of_range& e) {
19730       {
19731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19732       };
19733     } catch (std::exception& e) {
19734       {
19735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19736       };
19737     } catch (Dali::DaliException e) {
19738       {
19739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19740       };
19741     } catch (...) {
19742       {
19743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19744       };
19745     }
19746   }
19747
19748   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19749   return jresult;
19750 }
19751
19752
19753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19754   void * jresult ;
19755   float arg1 ;
19756   float arg2 ;
19757   Dali::PropertyCondition result;
19758
19759   arg1 = (float)jarg1;
19760   arg2 = (float)jarg2;
19761   {
19762     try {
19763       result = Dali::StepCondition(arg1,arg2);
19764     } catch (std::out_of_range& e) {
19765       {
19766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19767       };
19768     } catch (std::exception& e) {
19769       {
19770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19771       };
19772     } catch (Dali::DaliException e) {
19773       {
19774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19775       };
19776     } catch (...) {
19777       {
19778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19779       };
19780     }
19781   }
19782
19783   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19784   return jresult;
19785 }
19786
19787
19788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19789   void * jresult ;
19790   float arg1 ;
19791   Dali::PropertyCondition result;
19792
19793   arg1 = (float)jarg1;
19794   {
19795     try {
19796       result = Dali::StepCondition(arg1);
19797     } catch (std::out_of_range& e) {
19798       {
19799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19800       };
19801     } catch (std::exception& e) {
19802       {
19803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19804       };
19805     } catch (Dali::DaliException e) {
19806       {
19807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19808       };
19809     } catch (...) {
19810       {
19811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19812       };
19813     }
19814   }
19815
19816   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19817   return jresult;
19818 }
19819
19820
19821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19822   void * jresult ;
19823   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19824   Dali::PropertyCondition result;
19825
19826   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19827   if (!arg1) {
19828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19829     return 0;
19830   }
19831   {
19832     try {
19833       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19834     } catch (std::out_of_range& e) {
19835       {
19836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19837       };
19838     } catch (std::exception& e) {
19839       {
19840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19841       };
19842     } catch (Dali::DaliException e) {
19843       {
19844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19845       };
19846     } catch (...) {
19847       {
19848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19849       };
19850     }
19851   }
19852
19853   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19854   return jresult;
19855 }
19856
19857
19858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19859   void * jresult ;
19860   Dali::PropertyNotification *result = 0 ;
19861
19862   {
19863     try {
19864       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19865     } catch (std::out_of_range& e) {
19866       {
19867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19868       };
19869     } catch (std::exception& e) {
19870       {
19871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19872       };
19873     } catch (Dali::DaliException e) {
19874       {
19875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19876       };
19877     } catch (...) {
19878       {
19879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19880       };
19881     }
19882   }
19883
19884   jresult = (void *)result;
19885   return jresult;
19886 }
19887
19888
19889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19890   void * jresult ;
19891   Dali::BaseHandle arg1 ;
19892   Dali::BaseHandle *argp1 ;
19893   Dali::PropertyNotification result;
19894
19895   argp1 = (Dali::BaseHandle *)jarg1;
19896   if (!argp1) {
19897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19898     return 0;
19899   }
19900   arg1 = *argp1;
19901   {
19902     try {
19903       result = Dali::PropertyNotification::DownCast(arg1);
19904     } catch (std::out_of_range& e) {
19905       {
19906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19907       };
19908     } catch (std::exception& e) {
19909       {
19910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19911       };
19912     } catch (Dali::DaliException e) {
19913       {
19914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19915       };
19916     } catch (...) {
19917       {
19918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19919       };
19920     }
19921   }
19922
19923   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19924   return jresult;
19925 }
19926
19927
19928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19929   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19930
19931   arg1 = (Dali::PropertyNotification *)jarg1;
19932   {
19933     try {
19934       delete arg1;
19935     } catch (std::out_of_range& e) {
19936       {
19937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19938       };
19939     } catch (std::exception& e) {
19940       {
19941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19942       };
19943     } catch (Dali::DaliException e) {
19944       {
19945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19946       };
19947     } catch (...) {
19948       {
19949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19950       };
19951     }
19952   }
19953
19954 }
19955
19956
19957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19958   void * jresult ;
19959   Dali::PropertyNotification *arg1 = 0 ;
19960   Dali::PropertyNotification *result = 0 ;
19961
19962   arg1 = (Dali::PropertyNotification *)jarg1;
19963   if (!arg1) {
19964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19965     return 0;
19966   }
19967   {
19968     try {
19969       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19970     } catch (std::out_of_range& e) {
19971       {
19972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19973       };
19974     } catch (std::exception& e) {
19975       {
19976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19977       };
19978     } catch (Dali::DaliException e) {
19979       {
19980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19981       };
19982     } catch (...) {
19983       {
19984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19985       };
19986     }
19987   }
19988
19989   jresult = (void *)result;
19990   return jresult;
19991 }
19992
19993
19994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19995   void * jresult ;
19996   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19997   Dali::PropertyNotification *arg2 = 0 ;
19998   Dali::PropertyNotification *result = 0 ;
19999
20000   arg1 = (Dali::PropertyNotification *)jarg1;
20001   arg2 = (Dali::PropertyNotification *)jarg2;
20002   if (!arg2) {
20003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
20004     return 0;
20005   }
20006   {
20007     try {
20008       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
20009     } catch (std::out_of_range& e) {
20010       {
20011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20012       };
20013     } catch (std::exception& e) {
20014       {
20015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20016       };
20017     } catch (Dali::DaliException e) {
20018       {
20019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20020       };
20021     } catch (...) {
20022       {
20023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20024       };
20025     }
20026   }
20027
20028   jresult = (void *)result;
20029   return jresult;
20030 }
20031
20032
20033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
20034   void * jresult ;
20035   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20036   Dali::PropertyCondition result;
20037
20038   arg1 = (Dali::PropertyNotification *)jarg1;
20039   {
20040     try {
20041       result = (arg1)->GetCondition();
20042     } catch (std::out_of_range& e) {
20043       {
20044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20045       };
20046     } catch (std::exception& e) {
20047       {
20048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20049       };
20050     } catch (Dali::DaliException e) {
20051       {
20052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20053       };
20054     } catch (...) {
20055       {
20056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20057       };
20058     }
20059   }
20060
20061   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20062   return jresult;
20063 }
20064
20065
20066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20067   void * jresult ;
20068   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20069   Dali::Handle result;
20070
20071   arg1 = (Dali::PropertyNotification *)jarg1;
20072   {
20073     try {
20074       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20075     } catch (std::out_of_range& e) {
20076       {
20077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20078       };
20079     } catch (std::exception& e) {
20080       {
20081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20082       };
20083     } catch (Dali::DaliException e) {
20084       {
20085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20086       };
20087     } catch (...) {
20088       {
20089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20090       };
20091     }
20092   }
20093
20094   jresult = new Dali::Handle((const Dali::Handle &)result);
20095   return jresult;
20096 }
20097
20098
20099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20100   int jresult ;
20101   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20102   Dali::Property::Index result;
20103
20104   arg1 = (Dali::PropertyNotification *)jarg1;
20105   {
20106     try {
20107       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20108     } catch (std::out_of_range& e) {
20109       {
20110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20111       };
20112     } catch (std::exception& e) {
20113       {
20114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20115       };
20116     } catch (Dali::DaliException e) {
20117       {
20118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20119       };
20120     } catch (...) {
20121       {
20122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20123       };
20124     }
20125   }
20126
20127   jresult = result;
20128   return jresult;
20129 }
20130
20131
20132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20133   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20134   Dali::PropertyNotification::NotifyMode arg2 ;
20135
20136   arg1 = (Dali::PropertyNotification *)jarg1;
20137   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20138   {
20139     try {
20140       (arg1)->SetNotifyMode(arg2);
20141     } catch (std::out_of_range& e) {
20142       {
20143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20144       };
20145     } catch (std::exception& e) {
20146       {
20147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20148       };
20149     } catch (Dali::DaliException e) {
20150       {
20151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20152       };
20153     } catch (...) {
20154       {
20155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20156       };
20157     }
20158   }
20159
20160 }
20161
20162
20163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20164   int jresult ;
20165   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20166   Dali::PropertyNotification::NotifyMode result;
20167
20168   arg1 = (Dali::PropertyNotification *)jarg1;
20169   {
20170     try {
20171       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20172     } catch (std::out_of_range& e) {
20173       {
20174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20175       };
20176     } catch (std::exception& e) {
20177       {
20178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20179       };
20180     } catch (Dali::DaliException e) {
20181       {
20182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20183       };
20184     } catch (...) {
20185       {
20186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20187       };
20188     }
20189   }
20190
20191   jresult = (int)result;
20192   return jresult;
20193 }
20194
20195
20196 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20197   unsigned int jresult ;
20198   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20199   bool result;
20200
20201   arg1 = (Dali::PropertyNotification *)jarg1;
20202   {
20203     try {
20204       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20205     } catch (std::out_of_range& e) {
20206       {
20207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20208       };
20209     } catch (std::exception& e) {
20210       {
20211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20212       };
20213     } catch (Dali::DaliException e) {
20214       {
20215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20216       };
20217     } catch (...) {
20218       {
20219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20220       };
20221     }
20222   }
20223
20224   jresult = result;
20225   return jresult;
20226 }
20227
20228
20229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20230   void * jresult ;
20231   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20232   Dali::PropertyNotifySignalType *result = 0 ;
20233
20234   arg1 = (Dali::PropertyNotification *)jarg1;
20235   {
20236     try {
20237       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20238     } catch (std::out_of_range& e) {
20239       {
20240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20241       };
20242     } catch (std::exception& e) {
20243       {
20244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20245       };
20246     } catch (Dali::DaliException e) {
20247       {
20248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20249       };
20250     } catch (...) {
20251       {
20252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20253       };
20254     }
20255   }
20256
20257   jresult = (void *)result;
20258   return jresult;
20259 }
20260
20261
20262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20263   void * jresult ;
20264   Dali::Handle *result = 0 ;
20265
20266   {
20267     try {
20268       result = (Dali::Handle *)new Dali::Handle();
20269     } catch (std::out_of_range& e) {
20270       {
20271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20272       };
20273     } catch (std::exception& e) {
20274       {
20275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20276       };
20277     } catch (Dali::DaliException e) {
20278       {
20279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20280       };
20281     } catch (...) {
20282       {
20283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20284       };
20285     }
20286   }
20287
20288   jresult = (void *)result;
20289   return jresult;
20290 }
20291
20292
20293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20294   void * jresult ;
20295   Dali::Handle result;
20296
20297   {
20298     try {
20299       result = Dali::Handle::New();
20300     } catch (std::out_of_range& e) {
20301       {
20302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20303       };
20304     } catch (std::exception& e) {
20305       {
20306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20307       };
20308     } catch (Dali::DaliException e) {
20309       {
20310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20311       };
20312     } catch (...) {
20313       {
20314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20315       };
20316     }
20317   }
20318
20319   jresult = new Dali::Handle((const Dali::Handle &)result);
20320   return jresult;
20321 }
20322
20323
20324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20325   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20326
20327   arg1 = (Dali::Handle *)jarg1;
20328   {
20329     try {
20330       delete arg1;
20331     } catch (std::out_of_range& e) {
20332       {
20333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20334       };
20335     } catch (std::exception& e) {
20336       {
20337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20338       };
20339     } catch (Dali::DaliException e) {
20340       {
20341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20342       };
20343     } catch (...) {
20344       {
20345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20346       };
20347     }
20348   }
20349
20350 }
20351
20352
20353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20354   void * jresult ;
20355   Dali::Handle *arg1 = 0 ;
20356   Dali::Handle *result = 0 ;
20357
20358   arg1 = (Dali::Handle *)jarg1;
20359   if (!arg1) {
20360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20361     return 0;
20362   }
20363   {
20364     try {
20365       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20366     } catch (std::out_of_range& e) {
20367       {
20368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20369       };
20370     } catch (std::exception& e) {
20371       {
20372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20373       };
20374     } catch (Dali::DaliException e) {
20375       {
20376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20377       };
20378     } catch (...) {
20379       {
20380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20381       };
20382     }
20383   }
20384
20385   jresult = (void *)result;
20386   return jresult;
20387 }
20388
20389
20390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20391   void * jresult ;
20392   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20393   Dali::Handle *arg2 = 0 ;
20394   Dali::Handle *result = 0 ;
20395
20396   arg1 = (Dali::Handle *)jarg1;
20397   arg2 = (Dali::Handle *)jarg2;
20398   if (!arg2) {
20399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20400     return 0;
20401   }
20402   {
20403     try {
20404       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20405     } catch (std::out_of_range& e) {
20406       {
20407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20408       };
20409     } catch (std::exception& e) {
20410       {
20411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20412       };
20413     } catch (Dali::DaliException e) {
20414       {
20415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20416       };
20417     } catch (...) {
20418       {
20419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20420       };
20421     }
20422   }
20423
20424   jresult = (void *)result;
20425   return jresult;
20426 }
20427
20428
20429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20430   void * jresult ;
20431   Dali::BaseHandle arg1 ;
20432   Dali::BaseHandle *argp1 ;
20433   Dali::Handle result;
20434
20435   argp1 = (Dali::BaseHandle *)jarg1;
20436   if (!argp1) {
20437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20438     return 0;
20439   }
20440   arg1 = *argp1;
20441   {
20442     try {
20443       result = Dali::Handle::DownCast(arg1);
20444     } catch (std::out_of_range& e) {
20445       {
20446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20447       };
20448     } catch (std::exception& e) {
20449       {
20450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20451       };
20452     } catch (Dali::DaliException e) {
20453       {
20454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20455       };
20456     } catch (...) {
20457       {
20458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20459       };
20460     }
20461   }
20462
20463   jresult = new Dali::Handle((const Dali::Handle &)result);
20464   return jresult;
20465 }
20466
20467
20468 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20469   unsigned int jresult ;
20470   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20471   Dali::Handle::Capability arg2 ;
20472   bool result;
20473
20474   arg1 = (Dali::Handle *)jarg1;
20475   arg2 = (Dali::Handle::Capability)jarg2;
20476   {
20477     try {
20478       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20479     } catch (std::out_of_range& e) {
20480       {
20481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20482       };
20483     } catch (std::exception& e) {
20484       {
20485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20486       };
20487     } catch (Dali::DaliException e) {
20488       {
20489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20490       };
20491     } catch (...) {
20492       {
20493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20494       };
20495     }
20496   }
20497
20498   jresult = result;
20499   return jresult;
20500 }
20501
20502
20503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20504   unsigned int jresult ;
20505   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20506   unsigned int result;
20507
20508   arg1 = (Dali::Handle *)jarg1;
20509   {
20510     try {
20511       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20512     } catch (std::out_of_range& e) {
20513       {
20514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20515       };
20516     } catch (std::exception& e) {
20517       {
20518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20519       };
20520     } catch (Dali::DaliException e) {
20521       {
20522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20523       };
20524     } catch (...) {
20525       {
20526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20527       };
20528     }
20529   }
20530
20531   jresult = result;
20532   return jresult;
20533 }
20534
20535
20536 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20537   char * jresult ;
20538   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20539   Dali::Property::Index arg2 ;
20540   std::string result;
20541
20542   arg1 = (Dali::Handle *)jarg1;
20543   arg2 = (Dali::Property::Index)jarg2;
20544   {
20545     try {
20546       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20547     } catch (std::out_of_range& e) {
20548       {
20549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20550       };
20551     } catch (std::exception& e) {
20552       {
20553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20554       };
20555     } catch (Dali::DaliException e) {
20556       {
20557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20558       };
20559     } catch (...) {
20560       {
20561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20562       };
20563     }
20564   }
20565
20566   jresult = SWIG_csharp_string_callback((&result)->c_str());
20567   return jresult;
20568 }
20569
20570
20571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20572   int jresult ;
20573   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20574   std::string *arg2 = 0 ;
20575   Dali::Property::Index result;
20576
20577   arg1 = (Dali::Handle *)jarg1;
20578   if (!jarg2) {
20579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20580     return 0;
20581   }
20582   std::string arg2_str(jarg2);
20583   arg2 = &arg2_str;
20584   {
20585     try {
20586       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20587     } catch (std::out_of_range& e) {
20588       {
20589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20590       };
20591     } catch (std::exception& e) {
20592       {
20593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20594       };
20595     } catch (Dali::DaliException e) {
20596       {
20597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20598       };
20599     } catch (...) {
20600       {
20601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20602       };
20603     }
20604   }
20605
20606   jresult = result;
20607
20608   //argout typemap for const std::string&
20609
20610   return jresult;
20611 }
20612
20613
20614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20615   unsigned int jresult ;
20616   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20617   Dali::Property::Index arg2 ;
20618   bool result;
20619
20620   arg1 = (Dali::Handle *)jarg1;
20621   arg2 = (Dali::Property::Index)jarg2;
20622   {
20623     try {
20624       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20625     } catch (std::out_of_range& e) {
20626       {
20627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20628       };
20629     } catch (std::exception& e) {
20630       {
20631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20632       };
20633     } catch (Dali::DaliException e) {
20634       {
20635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20636       };
20637     } catch (...) {
20638       {
20639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20640       };
20641     }
20642   }
20643
20644   jresult = result;
20645   return jresult;
20646 }
20647
20648
20649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20650   unsigned int jresult ;
20651   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20652   Dali::Property::Index arg2 ;
20653   bool result;
20654
20655   arg1 = (Dali::Handle *)jarg1;
20656   arg2 = (Dali::Property::Index)jarg2;
20657   {
20658     try {
20659       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20660     } catch (std::out_of_range& e) {
20661       {
20662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20663       };
20664     } catch (std::exception& e) {
20665       {
20666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20667       };
20668     } catch (Dali::DaliException e) {
20669       {
20670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20671       };
20672     } catch (...) {
20673       {
20674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20675       };
20676     }
20677   }
20678
20679   jresult = result;
20680   return jresult;
20681 }
20682
20683
20684 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20685   unsigned int jresult ;
20686   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20687   Dali::Property::Index arg2 ;
20688   bool result;
20689
20690   arg1 = (Dali::Handle *)jarg1;
20691   arg2 = (Dali::Property::Index)jarg2;
20692   {
20693     try {
20694       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20695     } catch (std::out_of_range& e) {
20696       {
20697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20698       };
20699     } catch (std::exception& e) {
20700       {
20701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20702       };
20703     } catch (Dali::DaliException e) {
20704       {
20705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20706       };
20707     } catch (...) {
20708       {
20709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20710       };
20711     }
20712   }
20713
20714   jresult = result;
20715   return jresult;
20716 }
20717
20718
20719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20720   int jresult ;
20721   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20722   Dali::Property::Index arg2 ;
20723   Dali::Property::Type result;
20724
20725   arg1 = (Dali::Handle *)jarg1;
20726   arg2 = (Dali::Property::Index)jarg2;
20727   {
20728     try {
20729       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20730     } catch (std::out_of_range& e) {
20731       {
20732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20733       };
20734     } catch (std::exception& e) {
20735       {
20736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20737       };
20738     } catch (Dali::DaliException e) {
20739       {
20740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20741       };
20742     } catch (...) {
20743       {
20744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20745       };
20746     }
20747   }
20748
20749   jresult = (int)result;
20750   return jresult;
20751 }
20752
20753
20754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20755   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20756   Dali::Property::Index arg2 ;
20757   Dali::Property::Value *arg3 = 0 ;
20758
20759   arg1 = (Dali::Handle *)jarg1;
20760   arg2 = (Dali::Property::Index)jarg2;
20761   arg3 = (Dali::Property::Value *)jarg3;
20762   if (!arg3) {
20763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20764     return ;
20765   }
20766   {
20767     try {
20768       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20769     } catch (std::out_of_range& e) {
20770       {
20771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20772       };
20773     } catch (std::exception& e) {
20774       {
20775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20776       };
20777     } catch (Dali::DaliException e) {
20778       {
20779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20780       };
20781     } catch (...) {
20782       {
20783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20784       };
20785     }
20786   }
20787
20788 }
20789
20790
20791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20792   int jresult ;
20793   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20794   std::string *arg2 = 0 ;
20795   Dali::Property::Value *arg3 = 0 ;
20796   Dali::Property::Index result;
20797
20798   arg1 = (Dali::Handle *)jarg1;
20799   if (!jarg2) {
20800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20801     return 0;
20802   }
20803   std::string arg2_str(jarg2);
20804   arg2 = &arg2_str;
20805   arg3 = (Dali::Property::Value *)jarg3;
20806   if (!arg3) {
20807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20808     return 0;
20809   }
20810   {
20811     try {
20812       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20813     } catch (std::out_of_range& e) {
20814       {
20815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20816       };
20817     } catch (std::exception& e) {
20818       {
20819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20820       };
20821     } catch (Dali::DaliException e) {
20822       {
20823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20824       };
20825     } catch (...) {
20826       {
20827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20828       };
20829     }
20830   }
20831
20832   jresult = result;
20833
20834   //argout typemap for const std::string&
20835
20836   return jresult;
20837 }
20838
20839
20840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20841   int jresult ;
20842   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20843   std::string *arg2 = 0 ;
20844   Dali::Property::Value *arg3 = 0 ;
20845   Dali::Property::AccessMode arg4 ;
20846   Dali::Property::Index result;
20847
20848   arg1 = (Dali::Handle *)jarg1;
20849   if (!jarg2) {
20850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20851     return 0;
20852   }
20853   std::string arg2_str(jarg2);
20854   arg2 = &arg2_str;
20855   arg3 = (Dali::Property::Value *)jarg3;
20856   if (!arg3) {
20857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20858     return 0;
20859   }
20860   arg4 = (Dali::Property::AccessMode)jarg4;
20861   {
20862     try {
20863       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20864     } catch (std::out_of_range& e) {
20865       {
20866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20867       };
20868     } catch (std::exception& e) {
20869       {
20870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20871       };
20872     } catch (Dali::DaliException e) {
20873       {
20874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20875       };
20876     } catch (...) {
20877       {
20878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20879       };
20880     }
20881   }
20882
20883   jresult = result;
20884
20885   //argout typemap for const std::string&
20886
20887   return jresult;
20888 }
20889
20890
20891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20892   void * jresult ;
20893   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20894   Dali::Property::Index arg2 ;
20895   Dali::Property::Value result;
20896
20897   arg1 = (Dali::Handle *)jarg1;
20898   arg2 = (Dali::Property::Index)jarg2;
20899   {
20900     try {
20901       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20902     } catch (std::out_of_range& e) {
20903       {
20904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20905       };
20906     } catch (std::exception& e) {
20907       {
20908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20909       };
20910     } catch (Dali::DaliException e) {
20911       {
20912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20913       };
20914     } catch (...) {
20915       {
20916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20917       };
20918     }
20919   }
20920
20921   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20922   return jresult;
20923 }
20924
20925
20926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20927   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20928   Dali::Property::IndexContainer *arg2 = 0 ;
20929
20930   arg1 = (Dali::Handle *)jarg1;
20931   arg2 = (Dali::Property::IndexContainer *)jarg2;
20932   if (!arg2) {
20933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20934     return ;
20935   }
20936   {
20937     try {
20938       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20939     } catch (std::out_of_range& e) {
20940       {
20941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20942       };
20943     } catch (std::exception& e) {
20944       {
20945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20946       };
20947     } catch (Dali::DaliException e) {
20948       {
20949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20950       };
20951     } catch (...) {
20952       {
20953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20954       };
20955     }
20956   }
20957
20958 }
20959
20960
20961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20962   void * jresult ;
20963   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20964   Dali::Property::Index arg2 ;
20965   Dali::PropertyCondition *arg3 = 0 ;
20966   Dali::PropertyNotification result;
20967
20968   arg1 = (Dali::Handle *)jarg1;
20969   arg2 = (Dali::Property::Index)jarg2;
20970   arg3 = (Dali::PropertyCondition *)jarg3;
20971   if (!arg3) {
20972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20973     return 0;
20974   }
20975   {
20976     try {
20977       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20978     } catch (std::out_of_range& e) {
20979       {
20980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20981       };
20982     } catch (std::exception& e) {
20983       {
20984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20985       };
20986     } catch (Dali::DaliException e) {
20987       {
20988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20989       };
20990     } catch (...) {
20991       {
20992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20993       };
20994     }
20995   }
20996
20997   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20998   return jresult;
20999 }
21000
21001
21002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
21003   void * jresult ;
21004   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21005   Dali::Property::Index arg2 ;
21006   int arg3 ;
21007   Dali::PropertyCondition *arg4 = 0 ;
21008   Dali::PropertyNotification result;
21009
21010   arg1 = (Dali::Handle *)jarg1;
21011   arg2 = (Dali::Property::Index)jarg2;
21012   arg3 = (int)jarg3;
21013   arg4 = (Dali::PropertyCondition *)jarg4;
21014   if (!arg4) {
21015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
21016     return 0;
21017   }
21018   {
21019     try {
21020       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
21021     } catch (std::out_of_range& e) {
21022       {
21023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21024       };
21025     } catch (std::exception& e) {
21026       {
21027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21028       };
21029     } catch (Dali::DaliException e) {
21030       {
21031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21032       };
21033     } catch (...) {
21034       {
21035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21036       };
21037     }
21038   }
21039
21040   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21041   return jresult;
21042 }
21043
21044
21045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21046   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21047   Dali::PropertyNotification arg2 ;
21048   Dali::PropertyNotification *argp2 ;
21049
21050   arg1 = (Dali::Handle *)jarg1;
21051   argp2 = (Dali::PropertyNotification *)jarg2;
21052   if (!argp2) {
21053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21054     return ;
21055   }
21056   arg2 = *argp2;
21057   {
21058     try {
21059       (arg1)->RemovePropertyNotification(arg2);
21060     } catch (std::out_of_range& e) {
21061       {
21062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21063       };
21064     } catch (std::exception& e) {
21065       {
21066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21067       };
21068     } catch (Dali::DaliException e) {
21069       {
21070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21071       };
21072     } catch (...) {
21073       {
21074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21075       };
21076     }
21077   }
21078
21079 }
21080
21081
21082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21083   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21084
21085   arg1 = (Dali::Handle *)jarg1;
21086   {
21087     try {
21088       (arg1)->RemovePropertyNotifications();
21089     } catch (std::out_of_range& e) {
21090       {
21091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21092       };
21093     } catch (std::exception& e) {
21094       {
21095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21096       };
21097     } catch (Dali::DaliException e) {
21098       {
21099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21100       };
21101     } catch (...) {
21102       {
21103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21104       };
21105     }
21106   }
21107
21108 }
21109
21110
21111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21112   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21113
21114   arg1 = (Dali::Handle *)jarg1;
21115   {
21116     try {
21117       (arg1)->RemoveConstraints();
21118     } catch (std::out_of_range& e) {
21119       {
21120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21121       };
21122     } catch (std::exception& e) {
21123       {
21124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21125       };
21126     } catch (Dali::DaliException e) {
21127       {
21128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21129       };
21130     } catch (...) {
21131       {
21132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21133       };
21134     }
21135   }
21136
21137 }
21138
21139
21140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21141   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21142   unsigned int arg2 ;
21143
21144   arg1 = (Dali::Handle *)jarg1;
21145   arg2 = (unsigned int)jarg2;
21146   {
21147     try {
21148       (arg1)->RemoveConstraints(arg2);
21149     } catch (std::out_of_range& e) {
21150       {
21151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21152       };
21153     } catch (std::exception& e) {
21154       {
21155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21156       };
21157     } catch (Dali::DaliException e) {
21158       {
21159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21160       };
21161     } catch (...) {
21162       {
21163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21164       };
21165     }
21166   }
21167
21168 }
21169
21170
21171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21172   int jresult ;
21173   Dali::Property::Index result;
21174
21175   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21176   jresult = result;
21177   return jresult;
21178 }
21179
21180
21181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21182   void * jresult ;
21183   Dali::Handle result;
21184
21185   {
21186     try {
21187       result = Dali::WeightObject::New();
21188     } catch (std::out_of_range& e) {
21189       {
21190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21191       };
21192     } catch (std::exception& e) {
21193       {
21194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21195       };
21196     } catch (Dali::DaliException e) {
21197       {
21198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21199       };
21200     } catch (...) {
21201       {
21202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21203       };
21204     }
21205   }
21206
21207   jresult = new Dali::Handle((const Dali::Handle &)result);
21208   return jresult;
21209 }
21210
21211
21212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21213   void * jresult ;
21214   Dali::TypeInfo *result = 0 ;
21215
21216   {
21217     try {
21218       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21219     } catch (std::out_of_range& e) {
21220       {
21221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21222       };
21223     } catch (std::exception& e) {
21224       {
21225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21226       };
21227     } catch (Dali::DaliException e) {
21228       {
21229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21230       };
21231     } catch (...) {
21232       {
21233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21234       };
21235     }
21236   }
21237
21238   jresult = (void *)result;
21239   return jresult;
21240 }
21241
21242
21243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21244   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21245
21246   arg1 = (Dali::TypeInfo *)jarg1;
21247   {
21248     try {
21249       delete arg1;
21250     } catch (std::out_of_range& e) {
21251       {
21252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21253       };
21254     } catch (std::exception& e) {
21255       {
21256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21257       };
21258     } catch (Dali::DaliException e) {
21259       {
21260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21261       };
21262     } catch (...) {
21263       {
21264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21265       };
21266     }
21267   }
21268
21269 }
21270
21271
21272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21273   void * jresult ;
21274   Dali::TypeInfo *arg1 = 0 ;
21275   Dali::TypeInfo *result = 0 ;
21276
21277   arg1 = (Dali::TypeInfo *)jarg1;
21278   if (!arg1) {
21279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21280     return 0;
21281   }
21282   {
21283     try {
21284       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21285     } catch (std::out_of_range& e) {
21286       {
21287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21288       };
21289     } catch (std::exception& e) {
21290       {
21291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21292       };
21293     } catch (Dali::DaliException e) {
21294       {
21295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21296       };
21297     } catch (...) {
21298       {
21299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21300       };
21301     }
21302   }
21303
21304   jresult = (void *)result;
21305   return jresult;
21306 }
21307
21308
21309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21310   void * jresult ;
21311   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21312   Dali::TypeInfo *arg2 = 0 ;
21313   Dali::TypeInfo *result = 0 ;
21314
21315   arg1 = (Dali::TypeInfo *)jarg1;
21316   arg2 = (Dali::TypeInfo *)jarg2;
21317   if (!arg2) {
21318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21319     return 0;
21320   }
21321   {
21322     try {
21323       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21324     } catch (std::out_of_range& e) {
21325       {
21326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21327       };
21328     } catch (std::exception& e) {
21329       {
21330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21331       };
21332     } catch (Dali::DaliException e) {
21333       {
21334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21335       };
21336     } catch (...) {
21337       {
21338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21339       };
21340     }
21341   }
21342
21343   jresult = (void *)result;
21344   return jresult;
21345 }
21346
21347
21348 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21349   char * jresult ;
21350   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21351   std::string *result = 0 ;
21352
21353   arg1 = (Dali::TypeInfo *)jarg1;
21354   {
21355     try {
21356       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21357     } catch (std::out_of_range& e) {
21358       {
21359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21360       };
21361     } catch (std::exception& e) {
21362       {
21363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21364       };
21365     } catch (Dali::DaliException e) {
21366       {
21367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21368       };
21369     } catch (...) {
21370       {
21371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21372       };
21373     }
21374   }
21375
21376   jresult = SWIG_csharp_string_callback(result->c_str());
21377   return jresult;
21378 }
21379
21380
21381 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21382   char * jresult ;
21383   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21384   std::string *result = 0 ;
21385
21386   arg1 = (Dali::TypeInfo *)jarg1;
21387   {
21388     try {
21389       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21390     } catch (std::out_of_range& e) {
21391       {
21392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21393       };
21394     } catch (std::exception& e) {
21395       {
21396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21397       };
21398     } catch (Dali::DaliException e) {
21399       {
21400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21401       };
21402     } catch (...) {
21403       {
21404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21405       };
21406     }
21407   }
21408
21409   jresult = SWIG_csharp_string_callback(result->c_str());
21410   return jresult;
21411 }
21412
21413
21414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21415   void * jresult ;
21416   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21417   Dali::BaseHandle result;
21418
21419   arg1 = (Dali::TypeInfo *)jarg1;
21420   {
21421     try {
21422       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21423     } catch (std::out_of_range& e) {
21424       {
21425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21426       };
21427     } catch (std::exception& e) {
21428       {
21429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21430       };
21431     } catch (Dali::DaliException e) {
21432       {
21433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21434       };
21435     } catch (...) {
21436       {
21437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21438       };
21439     }
21440   }
21441
21442   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21443   return jresult;
21444 }
21445
21446
21447 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21448   unsigned long jresult ;
21449   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21450   size_t result;
21451
21452   arg1 = (Dali::TypeInfo *)jarg1;
21453   {
21454     try {
21455       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21456     } catch (std::out_of_range& e) {
21457       {
21458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21459       };
21460     } catch (std::exception& e) {
21461       {
21462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21463       };
21464     } catch (Dali::DaliException e) {
21465       {
21466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21467       };
21468     } catch (...) {
21469       {
21470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21471       };
21472     }
21473   }
21474
21475   jresult = (unsigned long)result;
21476   return jresult;
21477 }
21478
21479
21480 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21481   char * jresult ;
21482   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21483   size_t arg2 ;
21484   std::string result;
21485
21486   arg1 = (Dali::TypeInfo *)jarg1;
21487   arg2 = (size_t)jarg2;
21488   {
21489     try {
21490       result = (arg1)->GetActionName(arg2);
21491     } catch (std::out_of_range& e) {
21492       {
21493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21494       };
21495     } catch (std::exception& e) {
21496       {
21497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21498       };
21499     } catch (Dali::DaliException e) {
21500       {
21501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21502       };
21503     } catch (...) {
21504       {
21505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21506       };
21507     }
21508   }
21509
21510   jresult = SWIG_csharp_string_callback((&result)->c_str());
21511   return jresult;
21512 }
21513
21514
21515 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21516   unsigned long jresult ;
21517   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21518   size_t result;
21519
21520   arg1 = (Dali::TypeInfo *)jarg1;
21521   {
21522     try {
21523       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21524     } catch (std::out_of_range& e) {
21525       {
21526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21527       };
21528     } catch (std::exception& e) {
21529       {
21530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21531       };
21532     } catch (Dali::DaliException e) {
21533       {
21534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21535       };
21536     } catch (...) {
21537       {
21538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21539       };
21540     }
21541   }
21542
21543   jresult = (unsigned long)result;
21544   return jresult;
21545 }
21546
21547
21548 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21549   char * jresult ;
21550   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21551   size_t arg2 ;
21552   std::string result;
21553
21554   arg1 = (Dali::TypeInfo *)jarg1;
21555   arg2 = (size_t)jarg2;
21556   {
21557     try {
21558       result = (arg1)->GetSignalName(arg2);
21559     } catch (std::out_of_range& e) {
21560       {
21561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21562       };
21563     } catch (std::exception& e) {
21564       {
21565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21566       };
21567     } catch (Dali::DaliException e) {
21568       {
21569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21570       };
21571     } catch (...) {
21572       {
21573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21574       };
21575     }
21576   }
21577
21578   jresult = SWIG_csharp_string_callback((&result)->c_str());
21579   return jresult;
21580 }
21581
21582
21583 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21584   unsigned long jresult ;
21585   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21586   size_t result;
21587
21588   arg1 = (Dali::TypeInfo *)jarg1;
21589   {
21590     try {
21591       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21592     } catch (std::out_of_range& e) {
21593       {
21594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21595       };
21596     } catch (std::exception& e) {
21597       {
21598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21599       };
21600     } catch (Dali::DaliException e) {
21601       {
21602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21603       };
21604     } catch (...) {
21605       {
21606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21607       };
21608     }
21609   }
21610
21611   jresult = (unsigned long)result;
21612   return jresult;
21613 }
21614
21615
21616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21617   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21618   Dali::Property::IndexContainer *arg2 = 0 ;
21619
21620   arg1 = (Dali::TypeInfo *)jarg1;
21621   arg2 = (Dali::Property::IndexContainer *)jarg2;
21622   if (!arg2) {
21623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21624     return ;
21625   }
21626   {
21627     try {
21628       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21629     } catch (std::out_of_range& e) {
21630       {
21631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21632       };
21633     } catch (std::exception& e) {
21634       {
21635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21636       };
21637     } catch (Dali::DaliException e) {
21638       {
21639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21640       };
21641     } catch (...) {
21642       {
21643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21644       };
21645     }
21646   }
21647
21648 }
21649
21650
21651 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21652   char * jresult ;
21653   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21654   Dali::Property::Index arg2 ;
21655   std::string *result = 0 ;
21656
21657   arg1 = (Dali::TypeInfo *)jarg1;
21658   arg2 = (Dali::Property::Index)jarg2;
21659   {
21660     try {
21661       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21662     } catch (std::out_of_range& e) {
21663       {
21664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21665       };
21666     } catch (std::exception& e) {
21667       {
21668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21669       };
21670     } catch (Dali::DaliException e) {
21671       {
21672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21673       };
21674     } catch (...) {
21675       {
21676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21677       };
21678     }
21679   }
21680
21681   jresult = SWIG_csharp_string_callback(result->c_str());
21682   return jresult;
21683 }
21684
21685
21686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21687   void * jresult ;
21688   Dali::TypeRegistry result;
21689
21690   {
21691     try {
21692       result = Dali::TypeRegistry::Get();
21693     } catch (std::out_of_range& e) {
21694       {
21695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21696       };
21697     } catch (std::exception& e) {
21698       {
21699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21700       };
21701     } catch (Dali::DaliException e) {
21702       {
21703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21704       };
21705     } catch (...) {
21706       {
21707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21708       };
21709     }
21710   }
21711
21712   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21713   return jresult;
21714 }
21715
21716
21717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21718   void * jresult ;
21719   Dali::TypeRegistry *result = 0 ;
21720
21721   {
21722     try {
21723       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21724     } catch (std::out_of_range& e) {
21725       {
21726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21727       };
21728     } catch (std::exception& e) {
21729       {
21730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21731       };
21732     } catch (Dali::DaliException e) {
21733       {
21734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21735       };
21736     } catch (...) {
21737       {
21738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21739       };
21740     }
21741   }
21742
21743   jresult = (void *)result;
21744   return jresult;
21745 }
21746
21747
21748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21749   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21750
21751   arg1 = (Dali::TypeRegistry *)jarg1;
21752   {
21753     try {
21754       delete arg1;
21755     } catch (std::out_of_range& e) {
21756       {
21757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21758       };
21759     } catch (std::exception& e) {
21760       {
21761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21762       };
21763     } catch (Dali::DaliException e) {
21764       {
21765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21766       };
21767     } catch (...) {
21768       {
21769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21770       };
21771     }
21772   }
21773
21774 }
21775
21776
21777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21778   void * jresult ;
21779   Dali::TypeRegistry *arg1 = 0 ;
21780   Dali::TypeRegistry *result = 0 ;
21781
21782   arg1 = (Dali::TypeRegistry *)jarg1;
21783   if (!arg1) {
21784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21785     return 0;
21786   }
21787   {
21788     try {
21789       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21790     } catch (std::out_of_range& e) {
21791       {
21792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21793       };
21794     } catch (std::exception& e) {
21795       {
21796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21797       };
21798     } catch (Dali::DaliException e) {
21799       {
21800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21801       };
21802     } catch (...) {
21803       {
21804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21805       };
21806     }
21807   }
21808
21809   jresult = (void *)result;
21810   return jresult;
21811 }
21812
21813
21814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21815   void * jresult ;
21816   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21817   Dali::TypeRegistry *arg2 = 0 ;
21818   Dali::TypeRegistry *result = 0 ;
21819
21820   arg1 = (Dali::TypeRegistry *)jarg1;
21821   arg2 = (Dali::TypeRegistry *)jarg2;
21822   if (!arg2) {
21823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21824     return 0;
21825   }
21826   {
21827     try {
21828       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21829     } catch (std::out_of_range& e) {
21830       {
21831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21832       };
21833     } catch (std::exception& e) {
21834       {
21835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21836       };
21837     } catch (Dali::DaliException e) {
21838       {
21839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21840       };
21841     } catch (...) {
21842       {
21843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21844       };
21845     }
21846   }
21847
21848   jresult = (void *)result;
21849   return jresult;
21850 }
21851
21852
21853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21854   void * jresult ;
21855   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21856   std::string *arg2 = 0 ;
21857   Dali::TypeInfo result;
21858
21859   arg1 = (Dali::TypeRegistry *)jarg1;
21860   if (!jarg2) {
21861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21862     return 0;
21863   }
21864   std::string arg2_str(jarg2);
21865   arg2 = &arg2_str;
21866   {
21867     try {
21868       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21869     } catch (std::out_of_range& e) {
21870       {
21871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21872       };
21873     } catch (std::exception& e) {
21874       {
21875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21876       };
21877     } catch (Dali::DaliException e) {
21878       {
21879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21880       };
21881     } catch (...) {
21882       {
21883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21884       };
21885     }
21886   }
21887
21888   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21889
21890   //argout typemap for const std::string&
21891
21892   return jresult;
21893 }
21894
21895
21896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21897   void * jresult ;
21898   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21899   std::type_info *arg2 = 0 ;
21900   Dali::TypeInfo result;
21901
21902   arg1 = (Dali::TypeRegistry *)jarg1;
21903   arg2 = (std::type_info *)jarg2;
21904   if (!arg2) {
21905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21906     return 0;
21907   }
21908   {
21909     try {
21910       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21911     } catch (std::out_of_range& e) {
21912       {
21913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21914       };
21915     } catch (std::exception& e) {
21916       {
21917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21918       };
21919     } catch (Dali::DaliException e) {
21920       {
21921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21922       };
21923     } catch (...) {
21924       {
21925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21926       };
21927     }
21928   }
21929
21930   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21931   return jresult;
21932 }
21933
21934
21935 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21936   unsigned long jresult ;
21937   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21938   size_t result;
21939
21940   arg1 = (Dali::TypeRegistry *)jarg1;
21941   {
21942     try {
21943       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21944     } catch (std::out_of_range& e) {
21945       {
21946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21947       };
21948     } catch (std::exception& e) {
21949       {
21950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21951       };
21952     } catch (Dali::DaliException e) {
21953       {
21954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21955       };
21956     } catch (...) {
21957       {
21958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21959       };
21960     }
21961   }
21962
21963   jresult = (unsigned long)result;
21964   return jresult;
21965 }
21966
21967
21968 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21969   char * jresult ;
21970   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21971   size_t arg2 ;
21972   std::string result;
21973
21974   arg1 = (Dali::TypeRegistry *)jarg1;
21975   arg2 = (size_t)jarg2;
21976   {
21977     try {
21978       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21979     } catch (std::out_of_range& e) {
21980       {
21981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21982       };
21983     } catch (std::exception& e) {
21984       {
21985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21986       };
21987     } catch (Dali::DaliException e) {
21988       {
21989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21990       };
21991     } catch (...) {
21992       {
21993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21994       };
21995     }
21996   }
21997
21998   jresult = SWIG_csharp_string_callback((&result)->c_str());
21999   return jresult;
22000 }
22001
22002
22003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22004   void * jresult ;
22005   std::type_info *arg1 = 0 ;
22006   std::type_info *arg2 = 0 ;
22007   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22008   Dali::TypeRegistration *result = 0 ;
22009
22010   arg1 = (std::type_info *)jarg1;
22011   if (!arg1) {
22012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22013     return 0;
22014   }
22015   arg2 = (std::type_info *)jarg2;
22016   if (!arg2) {
22017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22018     return 0;
22019   }
22020   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22021   {
22022     try {
22023       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
22024     } catch (std::out_of_range& e) {
22025       {
22026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22027       };
22028     } catch (std::exception& e) {
22029       {
22030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22031       };
22032     } catch (Dali::DaliException e) {
22033       {
22034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22035       };
22036     } catch (...) {
22037       {
22038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22039       };
22040     }
22041   }
22042
22043   jresult = (void *)result;
22044   return jresult;
22045 }
22046
22047
22048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22049   void * jresult ;
22050   std::type_info *arg1 = 0 ;
22051   std::type_info *arg2 = 0 ;
22052   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22053   bool arg4 ;
22054   Dali::TypeRegistration *result = 0 ;
22055
22056   arg1 = (std::type_info *)jarg1;
22057   if (!arg1) {
22058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22059     return 0;
22060   }
22061   arg2 = (std::type_info *)jarg2;
22062   if (!arg2) {
22063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22064     return 0;
22065   }
22066   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22067   arg4 = jarg4 ? true : false;
22068   {
22069     try {
22070       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22071     } catch (std::out_of_range& e) {
22072       {
22073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22074       };
22075     } catch (std::exception& e) {
22076       {
22077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22078       };
22079     } catch (Dali::DaliException e) {
22080       {
22081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22082       };
22083     } catch (...) {
22084       {
22085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22086       };
22087     }
22088   }
22089
22090   jresult = (void *)result;
22091   return jresult;
22092 }
22093
22094
22095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22096   void * jresult ;
22097   std::string *arg1 = 0 ;
22098   std::type_info *arg2 = 0 ;
22099   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22100   Dali::TypeRegistration *result = 0 ;
22101
22102   if (!jarg1) {
22103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22104     return 0;
22105   }
22106   std::string arg1_str(jarg1);
22107   arg1 = &arg1_str;
22108   arg2 = (std::type_info *)jarg2;
22109   if (!arg2) {
22110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22111     return 0;
22112   }
22113   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22114   {
22115     try {
22116       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22117     } catch (std::out_of_range& e) {
22118       {
22119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22120       };
22121     } catch (std::exception& e) {
22122       {
22123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22124       };
22125     } catch (Dali::DaliException e) {
22126       {
22127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22128       };
22129     } catch (...) {
22130       {
22131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22132       };
22133     }
22134   }
22135
22136   jresult = (void *)result;
22137
22138   //argout typemap for const std::string&
22139
22140   return jresult;
22141 }
22142
22143
22144 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22145   char * jresult ;
22146   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22147   std::string result;
22148
22149   arg1 = (Dali::TypeRegistration *)jarg1;
22150   {
22151     try {
22152       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22153     } catch (std::out_of_range& e) {
22154       {
22155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22156       };
22157     } catch (std::exception& e) {
22158       {
22159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22160       };
22161     } catch (Dali::DaliException e) {
22162       {
22163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22164       };
22165     } catch (...) {
22166       {
22167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22168       };
22169     }
22170   }
22171
22172   jresult = SWIG_csharp_string_callback((&result)->c_str());
22173   return jresult;
22174 }
22175
22176
22177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22178   std::string *arg1 = 0 ;
22179   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22180
22181   if (!jarg1) {
22182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22183     return ;
22184   }
22185   std::string arg1_str(jarg1);
22186   arg1 = &arg1_str;
22187   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22188   {
22189     try {
22190       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22191     } catch (std::out_of_range& e) {
22192       {
22193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22194       };
22195     } catch (std::exception& e) {
22196       {
22197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22198       };
22199     } catch (Dali::DaliException e) {
22200       {
22201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22202       };
22203     } catch (...) {
22204       {
22205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22206       };
22207     }
22208   }
22209
22210
22211   //argout typemap for const std::string&
22212
22213 }
22214
22215
22216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22217   std::string *arg1 = 0 ;
22218   std::string *arg2 = 0 ;
22219   int arg3 ;
22220   Dali::Property::Type arg4 ;
22221   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22222   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22223
22224   if (!jarg1) {
22225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22226     return ;
22227   }
22228   std::string arg1_str(jarg1);
22229   arg1 = &arg1_str;
22230   if (!jarg2) {
22231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22232     return ;
22233   }
22234   std::string arg2_str(jarg2);
22235   arg2 = &arg2_str;
22236   arg3 = (int)jarg3;
22237   arg4 = (Dali::Property::Type)jarg4;
22238   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22239   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22240   {
22241     try {
22242       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22243     } catch (std::out_of_range& e) {
22244       {
22245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22246       };
22247     } catch (std::exception& e) {
22248       {
22249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22250       };
22251     } catch (Dali::DaliException e) {
22252       {
22253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22254       };
22255     } catch (...) {
22256       {
22257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22258       };
22259     }
22260   }
22261
22262
22263   //argout typemap for const std::string&
22264
22265
22266   //argout typemap for const std::string&
22267
22268 }
22269
22270
22271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22272   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22273
22274   arg1 = (Dali::TypeRegistration *)jarg1;
22275   {
22276     try {
22277       delete arg1;
22278     } catch (std::out_of_range& e) {
22279       {
22280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22281       };
22282     } catch (std::exception& e) {
22283       {
22284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22285       };
22286     } catch (Dali::DaliException e) {
22287       {
22288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22289       };
22290     } catch (...) {
22291       {
22292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22293       };
22294     }
22295   }
22296
22297 }
22298
22299
22300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22301   void * jresult ;
22302   Dali::TypeRegistration *arg1 = 0 ;
22303   std::string *arg2 = 0 ;
22304   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22305   Dali::SignalConnectorType *result = 0 ;
22306
22307   arg1 = (Dali::TypeRegistration *)jarg1;
22308   if (!arg1) {
22309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22310     return 0;
22311   }
22312   if (!jarg2) {
22313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22314     return 0;
22315   }
22316   std::string arg2_str(jarg2);
22317   arg2 = &arg2_str;
22318   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22319   {
22320     try {
22321       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22322     } catch (std::out_of_range& e) {
22323       {
22324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22325       };
22326     } catch (std::exception& e) {
22327       {
22328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22329       };
22330     } catch (Dali::DaliException e) {
22331       {
22332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22333       };
22334     } catch (...) {
22335       {
22336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22337       };
22338     }
22339   }
22340
22341   jresult = (void *)result;
22342
22343   //argout typemap for const std::string&
22344
22345   return jresult;
22346 }
22347
22348
22349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22350   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22351
22352   arg1 = (Dali::SignalConnectorType *)jarg1;
22353   {
22354     try {
22355       delete arg1;
22356     } catch (std::out_of_range& e) {
22357       {
22358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22359       };
22360     } catch (std::exception& e) {
22361       {
22362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22363       };
22364     } catch (Dali::DaliException e) {
22365       {
22366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22367       };
22368     } catch (...) {
22369       {
22370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22371       };
22372     }
22373   }
22374
22375 }
22376
22377
22378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22379   void * jresult ;
22380   Dali::TypeRegistration *arg1 = 0 ;
22381   std::string *arg2 = 0 ;
22382   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22383   Dali::TypeAction *result = 0 ;
22384
22385   arg1 = (Dali::TypeRegistration *)jarg1;
22386   if (!arg1) {
22387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22388     return 0;
22389   }
22390   if (!jarg2) {
22391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22392     return 0;
22393   }
22394   std::string arg2_str(jarg2);
22395   arg2 = &arg2_str;
22396   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22397   {
22398     try {
22399       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22400     } catch (std::out_of_range& e) {
22401       {
22402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22403       };
22404     } catch (std::exception& e) {
22405       {
22406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22407       };
22408     } catch (Dali::DaliException e) {
22409       {
22410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22411       };
22412     } catch (...) {
22413       {
22414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22415       };
22416     }
22417   }
22418
22419   jresult = (void *)result;
22420
22421   //argout typemap for const std::string&
22422
22423   return jresult;
22424 }
22425
22426
22427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22428   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22429
22430   arg1 = (Dali::TypeAction *)jarg1;
22431   {
22432     try {
22433       delete arg1;
22434     } catch (std::out_of_range& e) {
22435       {
22436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22437       };
22438     } catch (std::exception& e) {
22439       {
22440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22441       };
22442     } catch (Dali::DaliException e) {
22443       {
22444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22445       };
22446     } catch (...) {
22447       {
22448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22449       };
22450     }
22451   }
22452
22453 }
22454
22455
22456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22457   void * jresult ;
22458   Dali::TypeRegistration *arg1 = 0 ;
22459   std::string *arg2 = 0 ;
22460   Dali::Property::Index arg3 ;
22461   Dali::Property::Type arg4 ;
22462   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22463   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22464   Dali::PropertyRegistration *result = 0 ;
22465
22466   arg1 = (Dali::TypeRegistration *)jarg1;
22467   if (!arg1) {
22468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22469     return 0;
22470   }
22471   if (!jarg2) {
22472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22473     return 0;
22474   }
22475   std::string arg2_str(jarg2);
22476   arg2 = &arg2_str;
22477   arg3 = (Dali::Property::Index)jarg3;
22478   arg4 = (Dali::Property::Type)jarg4;
22479   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22480   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22481   {
22482     try {
22483       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22484     } catch (std::out_of_range& e) {
22485       {
22486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22487       };
22488     } catch (std::exception& e) {
22489       {
22490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22491       };
22492     } catch (Dali::DaliException e) {
22493       {
22494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22495       };
22496     } catch (...) {
22497       {
22498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22499       };
22500     }
22501   }
22502
22503   jresult = (void *)result;
22504
22505   //argout typemap for const std::string&
22506
22507   return jresult;
22508 }
22509
22510
22511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22512   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22513
22514   arg1 = (Dali::PropertyRegistration *)jarg1;
22515   {
22516     try {
22517       delete arg1;
22518     } catch (std::out_of_range& e) {
22519       {
22520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22521       };
22522     } catch (std::exception& e) {
22523       {
22524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22525       };
22526     } catch (Dali::DaliException e) {
22527       {
22528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22529       };
22530     } catch (...) {
22531       {
22532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22533       };
22534     }
22535   }
22536
22537 }
22538
22539
22540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22541   void * jresult ;
22542   Dali::TypeRegistration *arg1 = 0 ;
22543   std::string *arg2 = 0 ;
22544   Dali::Property::Index arg3 ;
22545   Dali::Property::Type arg4 ;
22546   Dali::AnimatablePropertyRegistration *result = 0 ;
22547
22548   arg1 = (Dali::TypeRegistration *)jarg1;
22549   if (!arg1) {
22550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22551     return 0;
22552   }
22553   if (!jarg2) {
22554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22555     return 0;
22556   }
22557   std::string arg2_str(jarg2);
22558   arg2 = &arg2_str;
22559   arg3 = (Dali::Property::Index)jarg3;
22560   arg4 = (Dali::Property::Type)jarg4;
22561   {
22562     try {
22563       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22564     } catch (std::out_of_range& e) {
22565       {
22566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22567       };
22568     } catch (std::exception& e) {
22569       {
22570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22571       };
22572     } catch (Dali::DaliException e) {
22573       {
22574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22575       };
22576     } catch (...) {
22577       {
22578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22579       };
22580     }
22581   }
22582
22583   jresult = (void *)result;
22584
22585   //argout typemap for const std::string&
22586
22587   return jresult;
22588 }
22589
22590
22591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22592   void * jresult ;
22593   Dali::TypeRegistration *arg1 = 0 ;
22594   std::string *arg2 = 0 ;
22595   Dali::Property::Index arg3 ;
22596   Dali::Property::Value *arg4 = 0 ;
22597   Dali::AnimatablePropertyRegistration *result = 0 ;
22598
22599   arg1 = (Dali::TypeRegistration *)jarg1;
22600   if (!arg1) {
22601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22602     return 0;
22603   }
22604   if (!jarg2) {
22605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22606     return 0;
22607   }
22608   std::string arg2_str(jarg2);
22609   arg2 = &arg2_str;
22610   arg3 = (Dali::Property::Index)jarg3;
22611   arg4 = (Dali::Property::Value *)jarg4;
22612   if (!arg4) {
22613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22614     return 0;
22615   }
22616   {
22617     try {
22618       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22619     } catch (std::out_of_range& e) {
22620       {
22621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22622       };
22623     } catch (std::exception& e) {
22624       {
22625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22626       };
22627     } catch (Dali::DaliException e) {
22628       {
22629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22630       };
22631     } catch (...) {
22632       {
22633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22634       };
22635     }
22636   }
22637
22638   jresult = (void *)result;
22639
22640   //argout typemap for const std::string&
22641
22642   return jresult;
22643 }
22644
22645
22646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22647   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22648
22649   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22650   {
22651     try {
22652       delete arg1;
22653     } catch (std::out_of_range& e) {
22654       {
22655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22656       };
22657     } catch (std::exception& e) {
22658       {
22659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22660       };
22661     } catch (Dali::DaliException e) {
22662       {
22663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22664       };
22665     } catch (...) {
22666       {
22667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22668       };
22669     }
22670   }
22671
22672 }
22673
22674
22675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22676   void * jresult ;
22677   Dali::TypeRegistration *arg1 = 0 ;
22678   std::string *arg2 = 0 ;
22679   Dali::Property::Index arg3 ;
22680   Dali::Property::Index arg4 ;
22681   unsigned int arg5 ;
22682   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22683
22684   arg1 = (Dali::TypeRegistration *)jarg1;
22685   if (!arg1) {
22686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22687     return 0;
22688   }
22689   if (!jarg2) {
22690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22691     return 0;
22692   }
22693   std::string arg2_str(jarg2);
22694   arg2 = &arg2_str;
22695   arg3 = (Dali::Property::Index)jarg3;
22696   arg4 = (Dali::Property::Index)jarg4;
22697   arg5 = (unsigned int)jarg5;
22698   {
22699     try {
22700       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22701     } catch (std::out_of_range& e) {
22702       {
22703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22704       };
22705     } catch (std::exception& e) {
22706       {
22707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22708       };
22709     } catch (Dali::DaliException e) {
22710       {
22711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22712       };
22713     } catch (...) {
22714       {
22715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22716       };
22717     }
22718   }
22719
22720   jresult = (void *)result;
22721
22722   //argout typemap for const std::string&
22723
22724   return jresult;
22725 }
22726
22727
22728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22729   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22730
22731   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22732   {
22733     try {
22734       delete arg1;
22735     } catch (std::out_of_range& e) {
22736       {
22737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22738       };
22739     } catch (std::exception& e) {
22740       {
22741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22742       };
22743     } catch (Dali::DaliException e) {
22744       {
22745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22746       };
22747     } catch (...) {
22748       {
22749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22750       };
22751     }
22752   }
22753
22754 }
22755
22756
22757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22758   void * jresult ;
22759   Dali::TypeRegistration *arg1 = 0 ;
22760   std::string *arg2 = 0 ;
22761   Dali::Property::Index arg3 ;
22762   Dali::Property::Type arg4 ;
22763   Dali::ChildPropertyRegistration *result = 0 ;
22764
22765   arg1 = (Dali::TypeRegistration *)jarg1;
22766   if (!arg1) {
22767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22768     return 0;
22769   }
22770   if (!jarg2) {
22771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22772     return 0;
22773   }
22774   std::string arg2_str(jarg2);
22775   arg2 = &arg2_str;
22776   arg3 = (Dali::Property::Index)jarg3;
22777   arg4 = (Dali::Property::Type)jarg4;
22778   {
22779     try {
22780       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22781     } catch (std::out_of_range& e) {
22782       {
22783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22784       };
22785     } catch (std::exception& e) {
22786       {
22787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22788       };
22789     } catch (Dali::DaliException e) {
22790       {
22791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22792       };
22793     } catch (...) {
22794       {
22795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22796       };
22797     }
22798   }
22799
22800   jresult = (void *)result;
22801
22802   //argout typemap for const std::string&
22803
22804   return jresult;
22805 }
22806
22807
22808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22809   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22810
22811   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22812   {
22813     try {
22814       delete arg1;
22815     } catch (std::out_of_range& e) {
22816       {
22817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22818       };
22819     } catch (std::exception& e) {
22820       {
22821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22822       };
22823     } catch (Dali::DaliException e) {
22824       {
22825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22826       };
22827     } catch (...) {
22828       {
22829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22830       };
22831     }
22832   }
22833
22834 }
22835
22836
22837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22838   unsigned int jresult ;
22839   std::string *arg1 = 0 ;
22840   std::type_info *arg2 = 0 ;
22841   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22842   bool result;
22843
22844   if (!jarg1) {
22845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22846     return 0;
22847   }
22848   std::string arg1_str(jarg1);
22849   arg1 = &arg1_str;
22850   arg2 = (std::type_info *)jarg2;
22851   if (!arg2) {
22852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22853     return 0;
22854   }
22855   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22856   {
22857     try {
22858       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22859     } catch (std::out_of_range& e) {
22860       {
22861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22862       };
22863     } catch (std::exception& e) {
22864       {
22865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22866       };
22867     } catch (Dali::DaliException e) {
22868       {
22869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22870       };
22871     } catch (...) {
22872       {
22873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22874       };
22875     }
22876   }
22877
22878   jresult = result;
22879
22880   //argout typemap for const std::string&
22881
22882   return jresult;
22883 }
22884
22885
22886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22887   unsigned int jresult ;
22888   std::string *arg1 = 0 ;
22889   std::string *arg2 = 0 ;
22890   Dali::Property::Index arg3 ;
22891   Dali::Property::Type arg4 ;
22892   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22893   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22894   bool result;
22895
22896   if (!jarg1) {
22897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22898     return 0;
22899   }
22900   std::string arg1_str(jarg1);
22901   arg1 = &arg1_str;
22902   if (!jarg2) {
22903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22904     return 0;
22905   }
22906   std::string arg2_str(jarg2);
22907   arg2 = &arg2_str;
22908   arg3 = (Dali::Property::Index)jarg3;
22909   arg4 = (Dali::Property::Type)jarg4;
22910   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22911   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22912   {
22913     try {
22914       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22915     } catch (std::out_of_range& e) {
22916       {
22917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22918       };
22919     } catch (std::exception& e) {
22920       {
22921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22922       };
22923     } catch (Dali::DaliException e) {
22924       {
22925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22926       };
22927     } catch (...) {
22928       {
22929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22930       };
22931     }
22932   }
22933
22934   jresult = result;
22935
22936   //argout typemap for const std::string&
22937
22938
22939   //argout typemap for const std::string&
22940
22941   return jresult;
22942 }
22943
22944
22945 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22946   float jresult ;
22947   float result;
22948
22949   result = (float)(float)Dali::ParentOrigin::TOP;
22950   jresult = result;
22951   return jresult;
22952 }
22953
22954
22955 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22956   float jresult ;
22957   float result;
22958
22959   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22960   jresult = result;
22961   return jresult;
22962 }
22963
22964
22965 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22966   float jresult ;
22967   float result;
22968
22969   result = (float)(float)Dali::ParentOrigin::LEFT;
22970   jresult = result;
22971   return jresult;
22972 }
22973
22974
22975 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22976   float jresult ;
22977   float result;
22978
22979   result = (float)(float)Dali::ParentOrigin::RIGHT;
22980   jresult = result;
22981   return jresult;
22982 }
22983
22984
22985 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22986   float jresult ;
22987   float result;
22988
22989   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22990   jresult = result;
22991   return jresult;
22992 }
22993
22994
22995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22996   void * jresult ;
22997   Dali::Vector3 *result = 0 ;
22998
22999   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
23000   jresult = (void *)result;
23001   return jresult;
23002 }
23003
23004
23005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
23006   void * jresult ;
23007   Dali::Vector3 *result = 0 ;
23008
23009   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
23010   jresult = (void *)result;
23011   return jresult;
23012 }
23013
23014
23015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
23016   void * jresult ;
23017   Dali::Vector3 *result = 0 ;
23018
23019   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
23020   jresult = (void *)result;
23021   return jresult;
23022 }
23023
23024
23025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
23026   void * jresult ;
23027   Dali::Vector3 *result = 0 ;
23028
23029   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
23030   jresult = (void *)result;
23031   return jresult;
23032 }
23033
23034
23035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23036   void * jresult ;
23037   Dali::Vector3 *result = 0 ;
23038
23039   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23040   jresult = (void *)result;
23041   return jresult;
23042 }
23043
23044
23045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23046   void * jresult ;
23047   Dali::Vector3 *result = 0 ;
23048
23049   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23050   jresult = (void *)result;
23051   return jresult;
23052 }
23053
23054
23055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23056   void * jresult ;
23057   Dali::Vector3 *result = 0 ;
23058
23059   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23060   jresult = (void *)result;
23061   return jresult;
23062 }
23063
23064
23065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23066   void * jresult ;
23067   Dali::Vector3 *result = 0 ;
23068
23069   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23070   jresult = (void *)result;
23071   return jresult;
23072 }
23073
23074
23075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23076   void * jresult ;
23077   Dali::Vector3 *result = 0 ;
23078
23079   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23080   jresult = (void *)result;
23081   return jresult;
23082 }
23083
23084
23085 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23086   float jresult ;
23087   float result;
23088
23089   result = (float)(float)Dali::AnchorPoint::TOP;
23090   jresult = result;
23091   return jresult;
23092 }
23093
23094
23095 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23096   float jresult ;
23097   float result;
23098
23099   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23100   jresult = result;
23101   return jresult;
23102 }
23103
23104
23105 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23106   float jresult ;
23107   float result;
23108
23109   result = (float)(float)Dali::AnchorPoint::LEFT;
23110   jresult = result;
23111   return jresult;
23112 }
23113
23114
23115 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23116   float jresult ;
23117   float result;
23118
23119   result = (float)(float)Dali::AnchorPoint::RIGHT;
23120   jresult = result;
23121   return jresult;
23122 }
23123
23124
23125 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23126   float jresult ;
23127   float result;
23128
23129   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23130   jresult = result;
23131   return jresult;
23132 }
23133
23134
23135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23136   void * jresult ;
23137   Dali::Vector3 *result = 0 ;
23138
23139   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23140   jresult = (void *)result;
23141   return jresult;
23142 }
23143
23144
23145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23146   void * jresult ;
23147   Dali::Vector3 *result = 0 ;
23148
23149   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23150   jresult = (void *)result;
23151   return jresult;
23152 }
23153
23154
23155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23156   void * jresult ;
23157   Dali::Vector3 *result = 0 ;
23158
23159   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23160   jresult = (void *)result;
23161   return jresult;
23162 }
23163
23164
23165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23166   void * jresult ;
23167   Dali::Vector3 *result = 0 ;
23168
23169   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23170   jresult = (void *)result;
23171   return jresult;
23172 }
23173
23174
23175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23176   void * jresult ;
23177   Dali::Vector3 *result = 0 ;
23178
23179   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23180   jresult = (void *)result;
23181   return jresult;
23182 }
23183
23184
23185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23186   void * jresult ;
23187   Dali::Vector3 *result = 0 ;
23188
23189   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23190   jresult = (void *)result;
23191   return jresult;
23192 }
23193
23194
23195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23196   void * jresult ;
23197   Dali::Vector3 *result = 0 ;
23198
23199   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23200   jresult = (void *)result;
23201   return jresult;
23202 }
23203
23204
23205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23206   void * jresult ;
23207   Dali::Vector3 *result = 0 ;
23208
23209   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23210   jresult = (void *)result;
23211   return jresult;
23212 }
23213
23214
23215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23216   void * jresult ;
23217   Dali::Vector3 *result = 0 ;
23218
23219   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23220   jresult = (void *)result;
23221   return jresult;
23222 }
23223
23224
23225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23226   void * jresult ;
23227   Dali::Vector4 *result = 0 ;
23228
23229   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23230   jresult = (void *)result;
23231   return jresult;
23232 }
23233
23234
23235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23236   void * jresult ;
23237   Dali::Vector4 *result = 0 ;
23238
23239   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23240   jresult = (void *)result;
23241   return jresult;
23242 }
23243
23244
23245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23246   void * jresult ;
23247   Dali::Vector4 *result = 0 ;
23248
23249   result = (Dali::Vector4 *)&Dali::Color::RED;
23250   jresult = (void *)result;
23251   return jresult;
23252 }
23253
23254
23255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23256   void * jresult ;
23257   Dali::Vector4 *result = 0 ;
23258
23259   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23260   jresult = (void *)result;
23261   return jresult;
23262 }
23263
23264
23265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23266   void * jresult ;
23267   Dali::Vector4 *result = 0 ;
23268
23269   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23270   jresult = (void *)result;
23271   return jresult;
23272 }
23273
23274
23275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23276   void * jresult ;
23277   Dali::Vector4 *result = 0 ;
23278
23279   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23280   jresult = (void *)result;
23281   return jresult;
23282 }
23283
23284
23285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23286   void * jresult ;
23287   Dali::Vector4 *result = 0 ;
23288
23289   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23290   jresult = (void *)result;
23291   return jresult;
23292 }
23293
23294
23295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23296   void * jresult ;
23297   Dali::Vector4 *result = 0 ;
23298
23299   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23300   jresult = (void *)result;
23301   return jresult;
23302 }
23303
23304
23305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23306   void * jresult ;
23307   Dali::Vector4 *result = 0 ;
23308
23309   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23310   jresult = (void *)result;
23311   return jresult;
23312 }
23313
23314
23315 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23316   float jresult ;
23317   float result;
23318
23319   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23320   jresult = result;
23321   return jresult;
23322 }
23323
23324
23325 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23326   float jresult ;
23327   float result;
23328
23329   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23330   jresult = result;
23331   return jresult;
23332 }
23333
23334
23335 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23336   float jresult ;
23337   float result;
23338
23339   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23340   jresult = result;
23341   return jresult;
23342 }
23343
23344
23345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23346   float jresult ;
23347   float result;
23348
23349   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23350   jresult = result;
23351   return jresult;
23352 }
23353
23354
23355 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23356   float jresult ;
23357   float result;
23358
23359   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23360   jresult = result;
23361   return jresult;
23362 }
23363
23364
23365 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23366   float jresult ;
23367   float result;
23368
23369   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23370   jresult = result;
23371   return jresult;
23372 }
23373
23374
23375 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23376   float jresult ;
23377   float result;
23378
23379   result = (float)(float)Dali::Math::PI;
23380   jresult = result;
23381   return jresult;
23382 }
23383
23384
23385 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23386   float jresult ;
23387   float result;
23388
23389   result = (float)(float)Dali::Math::PI_2;
23390   jresult = result;
23391   return jresult;
23392 }
23393
23394
23395 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23396   float jresult ;
23397   float result;
23398
23399   result = (float)(float)Dali::Math::PI_4;
23400   jresult = result;
23401   return jresult;
23402 }
23403
23404
23405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23406   float jresult ;
23407   float result;
23408
23409   result = (float)(float)Dali::Math::PI_OVER_180;
23410   jresult = result;
23411   return jresult;
23412 }
23413
23414
23415 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23416   float jresult ;
23417   float result;
23418
23419   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23420   jresult = result;
23421   return jresult;
23422 }
23423
23424
23425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23426   int jresult ;
23427   Dali::ResizePolicy::Type result;
23428
23429   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23430   jresult = (int)result;
23431   return jresult;
23432 }
23433
23434
23435 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23436   unsigned long jresult ;
23437   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23438   Dali::VectorBase::SizeType result;
23439
23440   arg1 = (Dali::VectorBase *)jarg1;
23441   {
23442     try {
23443       result = ((Dali::VectorBase const *)arg1)->Count();
23444     } catch (std::out_of_range& e) {
23445       {
23446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23447       };
23448     } catch (std::exception& e) {
23449       {
23450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23451       };
23452     } catch (Dali::DaliException e) {
23453       {
23454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23455       };
23456     } catch (...) {
23457       {
23458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23459       };
23460     }
23461   }
23462
23463   jresult = (unsigned long)result;
23464   return jresult;
23465 }
23466
23467
23468 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23469   unsigned long jresult ;
23470   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23471   Dali::VectorBase::SizeType result;
23472
23473   arg1 = (Dali::VectorBase *)jarg1;
23474   {
23475     try {
23476       result = ((Dali::VectorBase const *)arg1)->Size();
23477     } catch (std::out_of_range& e) {
23478       {
23479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23480       };
23481     } catch (std::exception& e) {
23482       {
23483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23484       };
23485     } catch (Dali::DaliException e) {
23486       {
23487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23488       };
23489     } catch (...) {
23490       {
23491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23492       };
23493     }
23494   }
23495
23496   jresult = (unsigned long)result;
23497   return jresult;
23498 }
23499
23500
23501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23502   unsigned int jresult ;
23503   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23504   bool result;
23505
23506   arg1 = (Dali::VectorBase *)jarg1;
23507   {
23508     try {
23509       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23510     } catch (std::out_of_range& e) {
23511       {
23512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23513       };
23514     } catch (std::exception& e) {
23515       {
23516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23517       };
23518     } catch (Dali::DaliException e) {
23519       {
23520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23521       };
23522     } catch (...) {
23523       {
23524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23525       };
23526     }
23527   }
23528
23529   jresult = result;
23530   return jresult;
23531 }
23532
23533
23534 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23535   unsigned long jresult ;
23536   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23537   Dali::VectorBase::SizeType result;
23538
23539   arg1 = (Dali::VectorBase *)jarg1;
23540   {
23541     try {
23542       result = ((Dali::VectorBase const *)arg1)->Capacity();
23543     } catch (std::out_of_range& e) {
23544       {
23545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23546       };
23547     } catch (std::exception& e) {
23548       {
23549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23550       };
23551     } catch (Dali::DaliException e) {
23552       {
23553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23554       };
23555     } catch (...) {
23556       {
23557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23558       };
23559     }
23560   }
23561
23562   jresult = (unsigned long)result;
23563   return jresult;
23564 }
23565
23566
23567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23568   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23569
23570   arg1 = (Dali::VectorBase *)jarg1;
23571   {
23572     try {
23573       (arg1)->Release();
23574     } catch (std::out_of_range& e) {
23575       {
23576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23577       };
23578     } catch (std::exception& e) {
23579       {
23580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23581       };
23582     } catch (Dali::DaliException e) {
23583       {
23584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23585       };
23586     } catch (...) {
23587       {
23588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23589       };
23590     }
23591   }
23592
23593 }
23594
23595
23596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23597   int jresult ;
23598   Dali::Pixel::Format result;
23599
23600   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23601   jresult = (int)result;
23602   return jresult;
23603 }
23604
23605
23606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23607   int jresult ;
23608   Dali::Pixel::Format result;
23609
23610   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23611   jresult = (int)result;
23612   return jresult;
23613 }
23614
23615
23616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23617   unsigned int jresult ;
23618   Dali::Pixel::Format arg1 ;
23619   bool result;
23620
23621   arg1 = (Dali::Pixel::Format)jarg1;
23622   {
23623     try {
23624       result = (bool)Dali::Pixel::HasAlpha(arg1);
23625     } catch (std::out_of_range& e) {
23626       {
23627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23628       };
23629     } catch (std::exception& e) {
23630       {
23631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23632       };
23633     } catch (Dali::DaliException e) {
23634       {
23635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23636       };
23637     } catch (...) {
23638       {
23639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23640       };
23641     }
23642   }
23643
23644   jresult = result;
23645   return jresult;
23646 }
23647
23648
23649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23650   unsigned int jresult ;
23651   Dali::Pixel::Format arg1 ;
23652   unsigned int result;
23653
23654   arg1 = (Dali::Pixel::Format)jarg1;
23655   {
23656     try {
23657       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23658     } catch (std::out_of_range& e) {
23659       {
23660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23661       };
23662     } catch (std::exception& e) {
23663       {
23664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23665       };
23666     } catch (Dali::DaliException e) {
23667       {
23668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23669       };
23670     } catch (...) {
23671       {
23672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23673       };
23674     }
23675   }
23676
23677   jresult = result;
23678   return jresult;
23679 }
23680
23681
23682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23683   Dali::Pixel::Format arg1 ;
23684   int *arg2 = 0 ;
23685   int *arg3 = 0 ;
23686
23687   arg1 = (Dali::Pixel::Format)jarg1;
23688   arg2 = (int *)jarg2;
23689   if (!arg2) {
23690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23691     return ;
23692   }
23693   arg3 = (int *)jarg3;
23694   if (!arg3) {
23695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23696     return ;
23697   }
23698   {
23699     try {
23700       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23701     } catch (std::out_of_range& e) {
23702       {
23703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23704       };
23705     } catch (std::exception& e) {
23706       {
23707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23708       };
23709     } catch (Dali::DaliException e) {
23710       {
23711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23712       };
23713     } catch (...) {
23714       {
23715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23716       };
23717     }
23718   }
23719
23720 }
23721
23722
23723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23724   void * jresult ;
23725   unsigned char *arg1 = (unsigned char *) 0 ;
23726   unsigned int arg2 ;
23727   unsigned int arg3 ;
23728   unsigned int arg4 ;
23729   Dali::Pixel::Format arg5 ;
23730   Dali::PixelData::ReleaseFunction arg6 ;
23731   Dali::PixelData result;
23732
23733   arg1 = jarg1;
23734   arg2 = (unsigned int)jarg2;
23735   arg3 = (unsigned int)jarg3;
23736   arg4 = (unsigned int)jarg4;
23737   arg5 = (Dali::Pixel::Format)jarg5;
23738   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23739   {
23740     try {
23741       auto pixelBuffer = new unsigned char[jarg2];
23742       memcpy( pixelBuffer, arg1, arg2);
23743       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
23744     } catch (std::out_of_range& e) {
23745       {
23746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23747       };
23748     } catch (std::exception& e) {
23749       {
23750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23751       };
23752     } catch (Dali::DaliException e) {
23753       {
23754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23755       };
23756     } catch (...) {
23757       {
23758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23759       };
23760     }
23761   }
23762
23763   jresult = new Dali::PixelData((const Dali::PixelData &)result);
23764
23765
23766   return jresult;
23767 }
23768
23769
23770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
23771   void * jresult ;
23772   Dali::PixelData *result = 0 ;
23773
23774   {
23775     try {
23776       result = (Dali::PixelData *)new Dali::PixelData();
23777     } catch (std::out_of_range& e) {
23778       {
23779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23780       };
23781     } catch (std::exception& e) {
23782       {
23783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23784       };
23785     } catch (Dali::DaliException e) {
23786       {
23787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23788       };
23789     } catch (...) {
23790       {
23791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23792       };
23793     }
23794   }
23795
23796   jresult = (void *)result;
23797   return jresult;
23798 }
23799
23800
23801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
23802   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23803
23804   arg1 = (Dali::PixelData *)jarg1;
23805   {
23806     try {
23807       delete arg1;
23808     } catch (std::out_of_range& e) {
23809       {
23810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23811       };
23812     } catch (std::exception& e) {
23813       {
23814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23815       };
23816     } catch (Dali::DaliException e) {
23817       {
23818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23819       };
23820     } catch (...) {
23821       {
23822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23823       };
23824     }
23825   }
23826
23827 }
23828
23829
23830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
23831   void * jresult ;
23832   Dali::PixelData *arg1 = 0 ;
23833   Dali::PixelData *result = 0 ;
23834
23835   arg1 = (Dali::PixelData *)jarg1;
23836   if (!arg1) {
23837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23838     return 0;
23839   }
23840   {
23841     try {
23842       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
23843     } catch (std::out_of_range& e) {
23844       {
23845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23846       };
23847     } catch (std::exception& e) {
23848       {
23849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23850       };
23851     } catch (Dali::DaliException e) {
23852       {
23853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23854       };
23855     } catch (...) {
23856       {
23857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23858       };
23859     }
23860   }
23861
23862   jresult = (void *)result;
23863   return jresult;
23864 }
23865
23866
23867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
23868   void * jresult ;
23869   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23870   Dali::PixelData *arg2 = 0 ;
23871   Dali::PixelData *result = 0 ;
23872
23873   arg1 = (Dali::PixelData *)jarg1;
23874   arg2 = (Dali::PixelData *)jarg2;
23875   if (!arg2) {
23876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23877     return 0;
23878   }
23879   {
23880     try {
23881       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
23882     } catch (std::out_of_range& e) {
23883       {
23884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23885       };
23886     } catch (std::exception& e) {
23887       {
23888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23889       };
23890     } catch (Dali::DaliException e) {
23891       {
23892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23893       };
23894     } catch (...) {
23895       {
23896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23897       };
23898     }
23899   }
23900
23901   jresult = (void *)result;
23902   return jresult;
23903 }
23904
23905
23906 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
23907   unsigned int jresult ;
23908   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23909   unsigned int result;
23910
23911   arg1 = (Dali::PixelData *)jarg1;
23912   {
23913     try {
23914       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
23915     } catch (std::out_of_range& e) {
23916       {
23917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23918       };
23919     } catch (std::exception& e) {
23920       {
23921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23922       };
23923     } catch (Dali::DaliException e) {
23924       {
23925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23926       };
23927     } catch (...) {
23928       {
23929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23930       };
23931     }
23932   }
23933
23934   jresult = result;
23935   return jresult;
23936 }
23937
23938
23939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
23940   unsigned int jresult ;
23941   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23942   unsigned int result;
23943
23944   arg1 = (Dali::PixelData *)jarg1;
23945   {
23946     try {
23947       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
23948     } catch (std::out_of_range& e) {
23949       {
23950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23951       };
23952     } catch (std::exception& e) {
23953       {
23954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23955       };
23956     } catch (Dali::DaliException e) {
23957       {
23958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23959       };
23960     } catch (...) {
23961       {
23962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23963       };
23964     }
23965   }
23966
23967   jresult = result;
23968   return jresult;
23969 }
23970
23971
23972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
23973   int jresult ;
23974   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23975   Dali::Pixel::Format result;
23976
23977   arg1 = (Dali::PixelData *)jarg1;
23978   {
23979     try {
23980       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
23981     } catch (std::out_of_range& e) {
23982       {
23983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23984       };
23985     } catch (std::exception& e) {
23986       {
23987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23988       };
23989     } catch (Dali::DaliException e) {
23990       {
23991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23992       };
23993     } catch (...) {
23994       {
23995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23996       };
23997     }
23998   }
23999
24000   jresult = (int)result;
24001   return jresult;
24002 }
24003
24004
24005 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24006   unsigned int jresult ;
24007   unsigned int result;
24008
24009   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24010   jresult = result;
24011   return jresult;
24012 }
24013
24014
24015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24016   unsigned int jresult ;
24017   unsigned int result;
24018
24019   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24020   jresult = result;
24021   return jresult;
24022 }
24023
24024
24025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24026   unsigned int jresult ;
24027   unsigned int result;
24028
24029   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24030   jresult = result;
24031   return jresult;
24032 }
24033
24034
24035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24036   unsigned int jresult ;
24037   unsigned int result;
24038
24039   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24040   jresult = result;
24041   return jresult;
24042 }
24043
24044
24045 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24046   unsigned int jresult ;
24047   unsigned int result;
24048
24049   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24050   jresult = result;
24051   return jresult;
24052 }
24053
24054
24055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24056   unsigned int jresult ;
24057   unsigned int result;
24058
24059   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24060   jresult = result;
24061   return jresult;
24062 }
24063
24064
24065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24066   void * jresult ;
24067   Dali::TextureType::Type arg1 ;
24068   Dali::Pixel::Format arg2 ;
24069   unsigned int arg3 ;
24070   unsigned int arg4 ;
24071   Dali::Texture result;
24072
24073   arg1 = (Dali::TextureType::Type)jarg1;
24074   arg2 = (Dali::Pixel::Format)jarg2;
24075   arg3 = (unsigned int)jarg3;
24076   arg4 = (unsigned int)jarg4;
24077   {
24078     try {
24079       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24080     } catch (std::out_of_range& e) {
24081       {
24082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24083       };
24084     } catch (std::exception& e) {
24085       {
24086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24087       };
24088     } catch (Dali::DaliException e) {
24089       {
24090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24091       };
24092     } catch (...) {
24093       {
24094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24095       };
24096     }
24097   }
24098
24099   jresult = new Dali::Texture((const Dali::Texture &)result);
24100   return jresult;
24101 }
24102
24103
24104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24105   void * jresult ;
24106   NativeImageInterface *arg1 = 0 ;
24107   Dali::Texture result;
24108
24109   arg1 = (NativeImageInterface *)jarg1;
24110   if (!arg1) {
24111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24112     return 0;
24113   }
24114   {
24115     try {
24116       result = Dali::Texture::New(*arg1);
24117     } catch (std::out_of_range& e) {
24118       {
24119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24120       };
24121     } catch (std::exception& e) {
24122       {
24123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24124       };
24125     } catch (Dali::DaliException e) {
24126       {
24127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24128       };
24129     } catch (...) {
24130       {
24131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24132       };
24133     }
24134   }
24135
24136   jresult = new Dali::Texture((const Dali::Texture &)result);
24137   return jresult;
24138 }
24139
24140
24141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24142   void * jresult ;
24143   Dali::Texture *result = 0 ;
24144
24145   {
24146     try {
24147       result = (Dali::Texture *)new Dali::Texture();
24148     } catch (std::out_of_range& e) {
24149       {
24150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24151       };
24152     } catch (std::exception& e) {
24153       {
24154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24155       };
24156     } catch (Dali::DaliException e) {
24157       {
24158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24159       };
24160     } catch (...) {
24161       {
24162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24163       };
24164     }
24165   }
24166
24167   jresult = (void *)result;
24168   return jresult;
24169 }
24170
24171
24172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24173   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24174
24175   arg1 = (Dali::Texture *)jarg1;
24176   {
24177     try {
24178       delete arg1;
24179     } catch (std::out_of_range& e) {
24180       {
24181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24182       };
24183     } catch (std::exception& e) {
24184       {
24185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24186       };
24187     } catch (Dali::DaliException e) {
24188       {
24189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24190       };
24191     } catch (...) {
24192       {
24193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24194       };
24195     }
24196   }
24197
24198 }
24199
24200
24201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24202   void * jresult ;
24203   Dali::Texture *arg1 = 0 ;
24204   Dali::Texture *result = 0 ;
24205
24206   arg1 = (Dali::Texture *)jarg1;
24207   if (!arg1) {
24208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24209     return 0;
24210   }
24211   {
24212     try {
24213       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24214     } catch (std::out_of_range& e) {
24215       {
24216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24217       };
24218     } catch (std::exception& e) {
24219       {
24220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24221       };
24222     } catch (Dali::DaliException e) {
24223       {
24224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24225       };
24226     } catch (...) {
24227       {
24228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24229       };
24230     }
24231   }
24232
24233   jresult = (void *)result;
24234   return jresult;
24235 }
24236
24237
24238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24239   void * jresult ;
24240   Dali::BaseHandle arg1 ;
24241   Dali::BaseHandle *argp1 ;
24242   Dali::Texture result;
24243
24244   argp1 = (Dali::BaseHandle *)jarg1;
24245   if (!argp1) {
24246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24247     return 0;
24248   }
24249   arg1 = *argp1;
24250   {
24251     try {
24252       result = Dali::Texture::DownCast(arg1);
24253     } catch (std::out_of_range& e) {
24254       {
24255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24256       };
24257     } catch (std::exception& e) {
24258       {
24259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24260       };
24261     } catch (Dali::DaliException e) {
24262       {
24263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24264       };
24265     } catch (...) {
24266       {
24267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24268       };
24269     }
24270   }
24271
24272   jresult = new Dali::Texture((const Dali::Texture &)result);
24273   return jresult;
24274 }
24275
24276
24277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24278   void * jresult ;
24279   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24280   Dali::Texture *arg2 = 0 ;
24281   Dali::Texture *result = 0 ;
24282
24283   arg1 = (Dali::Texture *)jarg1;
24284   arg2 = (Dali::Texture *)jarg2;
24285   if (!arg2) {
24286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24287     return 0;
24288   }
24289   {
24290     try {
24291       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24292     } catch (std::out_of_range& e) {
24293       {
24294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24295       };
24296     } catch (std::exception& e) {
24297       {
24298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24299       };
24300     } catch (Dali::DaliException e) {
24301       {
24302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24303       };
24304     } catch (...) {
24305       {
24306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24307       };
24308     }
24309   }
24310
24311   jresult = (void *)result;
24312   return jresult;
24313 }
24314
24315
24316 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24317   unsigned int jresult ;
24318   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24319   Dali::PixelData arg2 ;
24320   Dali::PixelData *argp2 ;
24321   bool result;
24322
24323   arg1 = (Dali::Texture *)jarg1;
24324   argp2 = (Dali::PixelData *)jarg2;
24325   if (!argp2) {
24326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24327     return 0;
24328   }
24329   arg2 = *argp2;
24330   {
24331     try {
24332       result = (bool)(arg1)->Upload(arg2);
24333     } catch (std::out_of_range& e) {
24334       {
24335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24336       };
24337     } catch (std::exception& e) {
24338       {
24339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24340       };
24341     } catch (Dali::DaliException e) {
24342       {
24343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24344       };
24345     } catch (...) {
24346       {
24347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24348       };
24349     }
24350   }
24351
24352   jresult = result;
24353   return jresult;
24354 }
24355
24356
24357 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) {
24358   unsigned int jresult ;
24359   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24360   Dali::PixelData arg2 ;
24361   unsigned int arg3 ;
24362   unsigned int arg4 ;
24363   unsigned int arg5 ;
24364   unsigned int arg6 ;
24365   unsigned int arg7 ;
24366   unsigned int arg8 ;
24367   Dali::PixelData *argp2 ;
24368   bool result;
24369
24370   arg1 = (Dali::Texture *)jarg1;
24371   argp2 = (Dali::PixelData *)jarg2;
24372   if (!argp2) {
24373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24374     return 0;
24375   }
24376   arg2 = *argp2;
24377   arg3 = (unsigned int)jarg3;
24378   arg4 = (unsigned int)jarg4;
24379   arg5 = (unsigned int)jarg5;
24380   arg6 = (unsigned int)jarg6;
24381   arg7 = (unsigned int)jarg7;
24382   arg8 = (unsigned int)jarg8;
24383   {
24384     try {
24385       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24386     } catch (std::out_of_range& e) {
24387       {
24388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24389       };
24390     } catch (std::exception& e) {
24391       {
24392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24393       };
24394     } catch (Dali::DaliException e) {
24395       {
24396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24397       };
24398     } catch (...) {
24399       {
24400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24401       };
24402     }
24403   }
24404
24405   jresult = result;
24406   return jresult;
24407 }
24408
24409
24410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24411   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24412
24413   arg1 = (Dali::Texture *)jarg1;
24414   {
24415     try {
24416       (arg1)->GenerateMipmaps();
24417     } catch (std::out_of_range& e) {
24418       {
24419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24420       };
24421     } catch (std::exception& e) {
24422       {
24423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24424       };
24425     } catch (Dali::DaliException e) {
24426       {
24427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24428       };
24429     } catch (...) {
24430       {
24431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24432       };
24433     }
24434   }
24435
24436 }
24437
24438
24439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24440   unsigned int jresult ;
24441   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24442   unsigned int result;
24443
24444   arg1 = (Dali::Texture *)jarg1;
24445   {
24446     try {
24447       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24448     } catch (std::out_of_range& e) {
24449       {
24450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24451       };
24452     } catch (std::exception& e) {
24453       {
24454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24455       };
24456     } catch (Dali::DaliException e) {
24457       {
24458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24459       };
24460     } catch (...) {
24461       {
24462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24463       };
24464     }
24465   }
24466
24467   jresult = result;
24468   return jresult;
24469 }
24470
24471
24472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24473   unsigned int jresult ;
24474   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24475   unsigned int result;
24476
24477   arg1 = (Dali::Texture *)jarg1;
24478   {
24479     try {
24480       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24481     } catch (std::out_of_range& e) {
24482       {
24483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24484       };
24485     } catch (std::exception& e) {
24486       {
24487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24488       };
24489     } catch (Dali::DaliException e) {
24490       {
24491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24492       };
24493     } catch (...) {
24494       {
24495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24496       };
24497     }
24498   }
24499
24500   jresult = result;
24501   return jresult;
24502 }
24503
24504
24505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24506   void * jresult ;
24507   Dali::Sampler result;
24508
24509   {
24510     try {
24511       result = Dali::Sampler::New();
24512     } catch (std::out_of_range& e) {
24513       {
24514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24515       };
24516     } catch (std::exception& e) {
24517       {
24518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24519       };
24520     } catch (Dali::DaliException e) {
24521       {
24522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24523       };
24524     } catch (...) {
24525       {
24526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24527       };
24528     }
24529   }
24530
24531   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24532   return jresult;
24533 }
24534
24535
24536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24537   void * jresult ;
24538   Dali::Sampler *result = 0 ;
24539
24540   {
24541     try {
24542       result = (Dali::Sampler *)new Dali::Sampler();
24543     } catch (std::out_of_range& e) {
24544       {
24545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24546       };
24547     } catch (std::exception& e) {
24548       {
24549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24550       };
24551     } catch (Dali::DaliException e) {
24552       {
24553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24554       };
24555     } catch (...) {
24556       {
24557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24558       };
24559     }
24560   }
24561
24562   jresult = (void *)result;
24563   return jresult;
24564 }
24565
24566
24567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24568   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24569
24570   arg1 = (Dali::Sampler *)jarg1;
24571   {
24572     try {
24573       delete arg1;
24574     } catch (std::out_of_range& e) {
24575       {
24576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24577       };
24578     } catch (std::exception& e) {
24579       {
24580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24581       };
24582     } catch (Dali::DaliException e) {
24583       {
24584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24585       };
24586     } catch (...) {
24587       {
24588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24589       };
24590     }
24591   }
24592
24593 }
24594
24595
24596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24597   void * jresult ;
24598   Dali::Sampler *arg1 = 0 ;
24599   Dali::Sampler *result = 0 ;
24600
24601   arg1 = (Dali::Sampler *)jarg1;
24602   if (!arg1) {
24603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24604     return 0;
24605   }
24606   {
24607     try {
24608       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24609     } catch (std::out_of_range& e) {
24610       {
24611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24612       };
24613     } catch (std::exception& e) {
24614       {
24615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24616       };
24617     } catch (Dali::DaliException e) {
24618       {
24619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24620       };
24621     } catch (...) {
24622       {
24623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24624       };
24625     }
24626   }
24627
24628   jresult = (void *)result;
24629   return jresult;
24630 }
24631
24632
24633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24634   void * jresult ;
24635   Dali::BaseHandle arg1 ;
24636   Dali::BaseHandle *argp1 ;
24637   Dali::Sampler result;
24638
24639   argp1 = (Dali::BaseHandle *)jarg1;
24640   if (!argp1) {
24641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24642     return 0;
24643   }
24644   arg1 = *argp1;
24645   {
24646     try {
24647       result = Dali::Sampler::DownCast(arg1);
24648     } catch (std::out_of_range& e) {
24649       {
24650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24651       };
24652     } catch (std::exception& e) {
24653       {
24654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24655       };
24656     } catch (Dali::DaliException e) {
24657       {
24658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24659       };
24660     } catch (...) {
24661       {
24662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24663       };
24664     }
24665   }
24666
24667   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24668   return jresult;
24669 }
24670
24671
24672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24673   void * jresult ;
24674   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24675   Dali::Sampler *arg2 = 0 ;
24676   Dali::Sampler *result = 0 ;
24677
24678   arg1 = (Dali::Sampler *)jarg1;
24679   arg2 = (Dali::Sampler *)jarg2;
24680   if (!arg2) {
24681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24682     return 0;
24683   }
24684   {
24685     try {
24686       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24687     } catch (std::out_of_range& e) {
24688       {
24689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24690       };
24691     } catch (std::exception& e) {
24692       {
24693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24694       };
24695     } catch (Dali::DaliException e) {
24696       {
24697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24698       };
24699     } catch (...) {
24700       {
24701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24702       };
24703     }
24704   }
24705
24706   jresult = (void *)result;
24707   return jresult;
24708 }
24709
24710
24711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24712   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24713   Dali::FilterMode::Type arg2 ;
24714   Dali::FilterMode::Type arg3 ;
24715
24716   arg1 = (Dali::Sampler *)jarg1;
24717   arg2 = (Dali::FilterMode::Type)jarg2;
24718   arg3 = (Dali::FilterMode::Type)jarg3;
24719   {
24720     try {
24721       (arg1)->SetFilterMode(arg2,arg3);
24722     } catch (std::out_of_range& e) {
24723       {
24724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24725       };
24726     } catch (std::exception& e) {
24727       {
24728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24729       };
24730     } catch (Dali::DaliException e) {
24731       {
24732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24733       };
24734     } catch (...) {
24735       {
24736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24737       };
24738     }
24739   }
24740
24741 }
24742
24743
24744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24745   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24746   Dali::WrapMode::Type arg2 ;
24747   Dali::WrapMode::Type arg3 ;
24748
24749   arg1 = (Dali::Sampler *)jarg1;
24750   arg2 = (Dali::WrapMode::Type)jarg2;
24751   arg3 = (Dali::WrapMode::Type)jarg3;
24752   {
24753     try {
24754       (arg1)->SetWrapMode(arg2,arg3);
24755     } catch (std::out_of_range& e) {
24756       {
24757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24758       };
24759     } catch (std::exception& e) {
24760       {
24761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24762       };
24763     } catch (Dali::DaliException e) {
24764       {
24765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24766       };
24767     } catch (...) {
24768       {
24769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24770       };
24771     }
24772   }
24773
24774 }
24775
24776
24777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
24778   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24779   Dali::WrapMode::Type arg2 ;
24780   Dali::WrapMode::Type arg3 ;
24781   Dali::WrapMode::Type arg4 ;
24782
24783   arg1 = (Dali::Sampler *)jarg1;
24784   arg2 = (Dali::WrapMode::Type)jarg2;
24785   arg3 = (Dali::WrapMode::Type)jarg3;
24786   arg4 = (Dali::WrapMode::Type)jarg4;
24787   {
24788     try {
24789       (arg1)->SetWrapMode(arg2,arg3,arg4);
24790     } catch (std::out_of_range& e) {
24791       {
24792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24793       };
24794     } catch (std::exception& e) {
24795       {
24796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24797       };
24798     } catch (Dali::DaliException e) {
24799       {
24800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24801       };
24802     } catch (...) {
24803       {
24804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24805       };
24806     }
24807   }
24808
24809 }
24810
24811
24812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
24813   void * jresult ;
24814   Dali::TextureSet result;
24815
24816   {
24817     try {
24818       result = Dali::TextureSet::New();
24819     } catch (std::out_of_range& e) {
24820       {
24821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24822       };
24823     } catch (std::exception& e) {
24824       {
24825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24826       };
24827     } catch (Dali::DaliException e) {
24828       {
24829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24830       };
24831     } catch (...) {
24832       {
24833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24834       };
24835     }
24836   }
24837
24838   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24839   return jresult;
24840 }
24841
24842
24843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
24844   void * jresult ;
24845   Dali::TextureSet *result = 0 ;
24846
24847   {
24848     try {
24849       result = (Dali::TextureSet *)new Dali::TextureSet();
24850     } catch (std::out_of_range& e) {
24851       {
24852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24853       };
24854     } catch (std::exception& e) {
24855       {
24856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24857       };
24858     } catch (Dali::DaliException e) {
24859       {
24860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24861       };
24862     } catch (...) {
24863       {
24864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24865       };
24866     }
24867   }
24868
24869   jresult = (void *)result;
24870   return jresult;
24871 }
24872
24873
24874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
24875   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
24876
24877   arg1 = (Dali::TextureSet *)jarg1;
24878   {
24879     try {
24880       delete arg1;
24881     } catch (std::out_of_range& e) {
24882       {
24883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24884       };
24885     } catch (std::exception& e) {
24886       {
24887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24888       };
24889     } catch (Dali::DaliException e) {
24890       {
24891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24892       };
24893     } catch (...) {
24894       {
24895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24896       };
24897     }
24898   }
24899
24900 }
24901
24902
24903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
24904   void * jresult ;
24905   Dali::TextureSet *arg1 = 0 ;
24906   Dali::TextureSet *result = 0 ;
24907
24908   arg1 = (Dali::TextureSet *)jarg1;
24909   if (!arg1) {
24910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
24911     return 0;
24912   }
24913   {
24914     try {
24915       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
24916     } catch (std::out_of_range& e) {
24917       {
24918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24919       };
24920     } catch (std::exception& e) {
24921       {
24922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24923       };
24924     } catch (Dali::DaliException e) {
24925       {
24926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24927       };
24928     } catch (...) {
24929       {
24930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24931       };
24932     }
24933   }
24934
24935   jresult = (void *)result;
24936   return jresult;
24937 }
24938
24939
24940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
24941   void * jresult ;
24942   Dali::BaseHandle arg1 ;
24943   Dali::BaseHandle *argp1 ;
24944   Dali::TextureSet result;
24945
24946   argp1 = (Dali::BaseHandle *)jarg1;
24947   if (!argp1) {
24948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24949     return 0;
24950   }
24951   arg1 = *argp1;
24952   {
24953     try {
24954       result = Dali::TextureSet::DownCast(arg1);
24955     } catch (std::out_of_range& e) {
24956       {
24957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24958       };
24959     } catch (std::exception& e) {
24960       {
24961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24962       };
24963     } catch (Dali::DaliException e) {
24964       {
24965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24966       };
24967     } catch (...) {
24968       {
24969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24970       };
24971     }
24972   }
24973
24974   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24975   return jresult;
24976 }
24977
24978
24979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
24980   void * jresult ;
24981   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
24982   Dali::TextureSet *arg2 = 0 ;
24983   Dali::TextureSet *result = 0 ;
24984
24985   arg1 = (Dali::TextureSet *)jarg1;
24986   arg2 = (Dali::TextureSet *)jarg2;
24987   if (!arg2) {
24988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
24989     return 0;
24990   }
24991   {
24992     try {
24993       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
24994     } catch (std::out_of_range& e) {
24995       {
24996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24997       };
24998     } catch (std::exception& e) {
24999       {
25000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25001       };
25002     } catch (Dali::DaliException e) {
25003       {
25004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25005       };
25006     } catch (...) {
25007       {
25008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25009       };
25010     }
25011   }
25012
25013   jresult = (void *)result;
25014   return jresult;
25015 }
25016
25017
25018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25019   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25020   size_t arg2 ;
25021   Dali::Texture arg3 ;
25022   Dali::Texture *argp3 ;
25023
25024   arg1 = (Dali::TextureSet *)jarg1;
25025   arg2 = (size_t)jarg2;
25026   argp3 = (Dali::Texture *)jarg3;
25027   if (!argp3) {
25028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25029     return ;
25030   }
25031   arg3 = *argp3;
25032   {
25033     try {
25034       (arg1)->SetTexture(arg2,arg3);
25035     } catch (std::out_of_range& e) {
25036       {
25037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25038       };
25039     } catch (std::exception& e) {
25040       {
25041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25042       };
25043     } catch (Dali::DaliException e) {
25044       {
25045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25046       };
25047     } catch (...) {
25048       {
25049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25050       };
25051     }
25052   }
25053
25054 }
25055
25056
25057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25058   void * jresult ;
25059   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25060   size_t arg2 ;
25061   Dali::Texture result;
25062
25063   arg1 = (Dali::TextureSet *)jarg1;
25064   arg2 = (size_t)jarg2;
25065   {
25066     try {
25067       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25068     } catch (std::out_of_range& e) {
25069       {
25070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25071       };
25072     } catch (std::exception& e) {
25073       {
25074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25075       };
25076     } catch (Dali::DaliException e) {
25077       {
25078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25079       };
25080     } catch (...) {
25081       {
25082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25083       };
25084     }
25085   }
25086
25087   jresult = new Dali::Texture((const Dali::Texture &)result);
25088   return jresult;
25089 }
25090
25091
25092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25093   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25094   size_t arg2 ;
25095   Dali::Sampler arg3 ;
25096   Dali::Sampler *argp3 ;
25097
25098   arg1 = (Dali::TextureSet *)jarg1;
25099   arg2 = (size_t)jarg2;
25100   argp3 = (Dali::Sampler *)jarg3;
25101   if (!argp3) {
25102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25103     return ;
25104   }
25105   arg3 = *argp3;
25106   {
25107     try {
25108       (arg1)->SetSampler(arg2,arg3);
25109     } catch (std::out_of_range& e) {
25110       {
25111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25112       };
25113     } catch (std::exception& e) {
25114       {
25115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25116       };
25117     } catch (Dali::DaliException e) {
25118       {
25119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25120       };
25121     } catch (...) {
25122       {
25123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25124       };
25125     }
25126   }
25127
25128 }
25129
25130
25131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25132   void * jresult ;
25133   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25134   size_t arg2 ;
25135   Dali::Sampler result;
25136
25137   arg1 = (Dali::TextureSet *)jarg1;
25138   arg2 = (size_t)jarg2;
25139   {
25140     try {
25141       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25142     } catch (std::out_of_range& e) {
25143       {
25144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25145       };
25146     } catch (std::exception& e) {
25147       {
25148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25149       };
25150     } catch (Dali::DaliException e) {
25151       {
25152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25153       };
25154     } catch (...) {
25155       {
25156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25157       };
25158     }
25159   }
25160
25161   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25162   return jresult;
25163 }
25164
25165
25166 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25167   unsigned long jresult ;
25168   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25169   size_t result;
25170
25171   arg1 = (Dali::TextureSet *)jarg1;
25172   {
25173     try {
25174       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25175     } catch (std::out_of_range& e) {
25176       {
25177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25178       };
25179     } catch (std::exception& e) {
25180       {
25181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25182       };
25183     } catch (Dali::DaliException e) {
25184       {
25185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25186       };
25187     } catch (...) {
25188       {
25189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25190       };
25191     }
25192   }
25193
25194   jresult = (unsigned long)result;
25195   return jresult;
25196 }
25197
25198
25199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25200   void * jresult ;
25201   Dali::Property::Map *arg1 = 0 ;
25202   Dali::PropertyBuffer result;
25203
25204   arg1 = (Dali::Property::Map *)jarg1;
25205   if (!arg1) {
25206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25207     return 0;
25208   }
25209   {
25210     try {
25211       result = Dali::PropertyBuffer::New(*arg1);
25212     } catch (std::out_of_range& e) {
25213       {
25214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25215       };
25216     } catch (std::exception& e) {
25217       {
25218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25219       };
25220     } catch (Dali::DaliException e) {
25221       {
25222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25223       };
25224     } catch (...) {
25225       {
25226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25227       };
25228     }
25229   }
25230
25231   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25232   return jresult;
25233 }
25234
25235
25236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25237   void * jresult ;
25238   Dali::PropertyBuffer *result = 0 ;
25239
25240   {
25241     try {
25242       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25243     } catch (std::out_of_range& e) {
25244       {
25245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25246       };
25247     } catch (std::exception& e) {
25248       {
25249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25250       };
25251     } catch (Dali::DaliException e) {
25252       {
25253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25254       };
25255     } catch (...) {
25256       {
25257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25258       };
25259     }
25260   }
25261
25262   jresult = (void *)result;
25263   return jresult;
25264 }
25265
25266
25267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25268   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25269
25270   arg1 = (Dali::PropertyBuffer *)jarg1;
25271   {
25272     try {
25273       delete arg1;
25274     } catch (std::out_of_range& e) {
25275       {
25276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25277       };
25278     } catch (std::exception& e) {
25279       {
25280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25281       };
25282     } catch (Dali::DaliException e) {
25283       {
25284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25285       };
25286     } catch (...) {
25287       {
25288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25289       };
25290     }
25291   }
25292
25293 }
25294
25295
25296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25297   void * jresult ;
25298   Dali::PropertyBuffer *arg1 = 0 ;
25299   Dali::PropertyBuffer *result = 0 ;
25300
25301   arg1 = (Dali::PropertyBuffer *)jarg1;
25302   if (!arg1) {
25303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25304     return 0;
25305   }
25306   {
25307     try {
25308       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25309     } catch (std::out_of_range& e) {
25310       {
25311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25312       };
25313     } catch (std::exception& e) {
25314       {
25315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25316       };
25317     } catch (Dali::DaliException e) {
25318       {
25319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25320       };
25321     } catch (...) {
25322       {
25323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25324       };
25325     }
25326   }
25327
25328   jresult = (void *)result;
25329   return jresult;
25330 }
25331
25332
25333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25334   void * jresult ;
25335   Dali::BaseHandle arg1 ;
25336   Dali::BaseHandle *argp1 ;
25337   Dali::PropertyBuffer result;
25338
25339   argp1 = (Dali::BaseHandle *)jarg1;
25340   if (!argp1) {
25341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25342     return 0;
25343   }
25344   arg1 = *argp1;
25345   {
25346     try {
25347       result = Dali::PropertyBuffer::DownCast(arg1);
25348     } catch (std::out_of_range& e) {
25349       {
25350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25351       };
25352     } catch (std::exception& e) {
25353       {
25354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25355       };
25356     } catch (Dali::DaliException e) {
25357       {
25358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25359       };
25360     } catch (...) {
25361       {
25362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25363       };
25364     }
25365   }
25366
25367   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25368   return jresult;
25369 }
25370
25371
25372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25373   void * jresult ;
25374   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25375   Dali::PropertyBuffer *arg2 = 0 ;
25376   Dali::PropertyBuffer *result = 0 ;
25377
25378   arg1 = (Dali::PropertyBuffer *)jarg1;
25379   arg2 = (Dali::PropertyBuffer *)jarg2;
25380   if (!arg2) {
25381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25382     return 0;
25383   }
25384   {
25385     try {
25386       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25387     } catch (std::out_of_range& e) {
25388       {
25389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25390       };
25391     } catch (std::exception& e) {
25392       {
25393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25394       };
25395     } catch (Dali::DaliException e) {
25396       {
25397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25398       };
25399     } catch (...) {
25400       {
25401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25402       };
25403     }
25404   }
25405
25406   jresult = (void *)result;
25407   return jresult;
25408 }
25409
25410
25411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25412   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25413   void *arg2 = (void *) 0 ;
25414   std::size_t arg3 ;
25415
25416   arg1 = (Dali::PropertyBuffer *)jarg1;
25417   arg2 = jarg2;
25418   arg3 = (std::size_t)jarg3;
25419   {
25420     try {
25421       (arg1)->SetData((void const *)arg2,arg3);
25422     } catch (std::out_of_range& e) {
25423       {
25424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25425       };
25426     } catch (std::exception& e) {
25427       {
25428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25429       };
25430     } catch (Dali::DaliException e) {
25431       {
25432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25433       };
25434     } catch (...) {
25435       {
25436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25437       };
25438     }
25439   }
25440
25441 }
25442
25443
25444 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25445   unsigned long jresult ;
25446   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25447   std::size_t result;
25448
25449   arg1 = (Dali::PropertyBuffer *)jarg1;
25450   {
25451     try {
25452       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25453     } catch (std::out_of_range& e) {
25454       {
25455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25456       };
25457     } catch (std::exception& e) {
25458       {
25459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25460       };
25461     } catch (Dali::DaliException e) {
25462       {
25463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25464       };
25465     } catch (...) {
25466       {
25467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25468       };
25469     }
25470   }
25471
25472   jresult = (unsigned long)result;
25473   return jresult;
25474 }
25475
25476
25477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25478   void * jresult ;
25479   Dali::Geometry result;
25480
25481   {
25482     try {
25483       result = Dali::Geometry::New();
25484     } catch (std::out_of_range& e) {
25485       {
25486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25487       };
25488     } catch (std::exception& e) {
25489       {
25490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25491       };
25492     } catch (Dali::DaliException e) {
25493       {
25494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25495       };
25496     } catch (...) {
25497       {
25498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25499       };
25500     }
25501   }
25502
25503   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25504   return jresult;
25505 }
25506
25507
25508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25509   void * jresult ;
25510   Dali::Geometry *result = 0 ;
25511
25512   {
25513     try {
25514       result = (Dali::Geometry *)new Dali::Geometry();
25515     } catch (std::out_of_range& e) {
25516       {
25517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25518       };
25519     } catch (std::exception& e) {
25520       {
25521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25522       };
25523     } catch (Dali::DaliException e) {
25524       {
25525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25526       };
25527     } catch (...) {
25528       {
25529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25530       };
25531     }
25532   }
25533
25534   jresult = (void *)result;
25535   return jresult;
25536 }
25537
25538
25539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25540   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25541
25542   arg1 = (Dali::Geometry *)jarg1;
25543   {
25544     try {
25545       delete arg1;
25546     } catch (std::out_of_range& e) {
25547       {
25548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25549       };
25550     } catch (std::exception& e) {
25551       {
25552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25553       };
25554     } catch (Dali::DaliException e) {
25555       {
25556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25557       };
25558     } catch (...) {
25559       {
25560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25561       };
25562     }
25563   }
25564
25565 }
25566
25567
25568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25569   void * jresult ;
25570   Dali::Geometry *arg1 = 0 ;
25571   Dali::Geometry *result = 0 ;
25572
25573   arg1 = (Dali::Geometry *)jarg1;
25574   if (!arg1) {
25575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25576     return 0;
25577   }
25578   {
25579     try {
25580       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25581     } catch (std::out_of_range& e) {
25582       {
25583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25584       };
25585     } catch (std::exception& e) {
25586       {
25587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25588       };
25589     } catch (Dali::DaliException e) {
25590       {
25591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25592       };
25593     } catch (...) {
25594       {
25595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25596       };
25597     }
25598   }
25599
25600   jresult = (void *)result;
25601   return jresult;
25602 }
25603
25604
25605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25606   void * jresult ;
25607   Dali::BaseHandle arg1 ;
25608   Dali::BaseHandle *argp1 ;
25609   Dali::Geometry result;
25610
25611   argp1 = (Dali::BaseHandle *)jarg1;
25612   if (!argp1) {
25613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25614     return 0;
25615   }
25616   arg1 = *argp1;
25617   {
25618     try {
25619       result = Dali::Geometry::DownCast(arg1);
25620     } catch (std::out_of_range& e) {
25621       {
25622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25623       };
25624     } catch (std::exception& e) {
25625       {
25626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25627       };
25628     } catch (Dali::DaliException e) {
25629       {
25630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25631       };
25632     } catch (...) {
25633       {
25634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25635       };
25636     }
25637   }
25638
25639   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25640   return jresult;
25641 }
25642
25643
25644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25645   void * jresult ;
25646   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25647   Dali::Geometry *arg2 = 0 ;
25648   Dali::Geometry *result = 0 ;
25649
25650   arg1 = (Dali::Geometry *)jarg1;
25651   arg2 = (Dali::Geometry *)jarg2;
25652   if (!arg2) {
25653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25654     return 0;
25655   }
25656   {
25657     try {
25658       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25659     } catch (std::out_of_range& e) {
25660       {
25661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25662       };
25663     } catch (std::exception& e) {
25664       {
25665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25666       };
25667     } catch (Dali::DaliException e) {
25668       {
25669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25670       };
25671     } catch (...) {
25672       {
25673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25674       };
25675     }
25676   }
25677
25678   jresult = (void *)result;
25679   return jresult;
25680 }
25681
25682
25683 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25684   unsigned long jresult ;
25685   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25686   Dali::PropertyBuffer *arg2 = 0 ;
25687   std::size_t result;
25688
25689   arg1 = (Dali::Geometry *)jarg1;
25690   arg2 = (Dali::PropertyBuffer *)jarg2;
25691   if (!arg2) {
25692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25693     return 0;
25694   }
25695   {
25696     try {
25697       result = (arg1)->AddVertexBuffer(*arg2);
25698     } catch (std::out_of_range& e) {
25699       {
25700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25701       };
25702     } catch (std::exception& e) {
25703       {
25704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25705       };
25706     } catch (Dali::DaliException e) {
25707       {
25708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25709       };
25710     } catch (...) {
25711       {
25712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25713       };
25714     }
25715   }
25716
25717   jresult = (unsigned long)result;
25718   return jresult;
25719 }
25720
25721
25722 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25723   unsigned long jresult ;
25724   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25725   std::size_t result;
25726
25727   arg1 = (Dali::Geometry *)jarg1;
25728   {
25729     try {
25730       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25731     } catch (std::out_of_range& e) {
25732       {
25733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25734       };
25735     } catch (std::exception& e) {
25736       {
25737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25738       };
25739     } catch (Dali::DaliException e) {
25740       {
25741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25742       };
25743     } catch (...) {
25744       {
25745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25746       };
25747     }
25748   }
25749
25750   jresult = (unsigned long)result;
25751   return jresult;
25752 }
25753
25754
25755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25756   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25757   std::size_t arg2 ;
25758
25759   arg1 = (Dali::Geometry *)jarg1;
25760   arg2 = (std::size_t)jarg2;
25761   {
25762     try {
25763       (arg1)->RemoveVertexBuffer(arg2);
25764     } catch (std::out_of_range& e) {
25765       {
25766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25767       };
25768     } catch (std::exception& e) {
25769       {
25770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25771       };
25772     } catch (Dali::DaliException e) {
25773       {
25774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25775       };
25776     } catch (...) {
25777       {
25778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25779       };
25780     }
25781   }
25782
25783 }
25784
25785
25786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
25787   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25788   unsigned short *arg2 = (unsigned short *) 0 ;
25789   size_t arg3 ;
25790
25791   arg1 = (Dali::Geometry *)jarg1;
25792   arg2 = jarg2;
25793   arg3 = (size_t)jarg3;
25794   {
25795     try {
25796       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
25797     } catch (std::out_of_range& e) {
25798       {
25799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25800       };
25801     } catch (std::exception& e) {
25802       {
25803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25804       };
25805     } catch (Dali::DaliException e) {
25806       {
25807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25808       };
25809     } catch (...) {
25810       {
25811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25812       };
25813     }
25814   }
25815
25816
25817
25818 }
25819
25820
25821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
25822   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25823   Dali::Geometry::Type arg2 ;
25824
25825   arg1 = (Dali::Geometry *)jarg1;
25826   arg2 = (Dali::Geometry::Type)jarg2;
25827   {
25828     try {
25829       (arg1)->SetType(arg2);
25830     } catch (std::out_of_range& e) {
25831       {
25832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25833       };
25834     } catch (std::exception& e) {
25835       {
25836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25837       };
25838     } catch (Dali::DaliException e) {
25839       {
25840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25841       };
25842     } catch (...) {
25843       {
25844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25845       };
25846     }
25847   }
25848
25849 }
25850
25851
25852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
25853   int jresult ;
25854   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25855   Dali::Geometry::Type result;
25856
25857   arg1 = (Dali::Geometry *)jarg1;
25858   {
25859     try {
25860       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
25861     } catch (std::out_of_range& e) {
25862       {
25863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25864       };
25865     } catch (std::exception& e) {
25866       {
25867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25868       };
25869     } catch (Dali::DaliException e) {
25870       {
25871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25872       };
25873     } catch (...) {
25874       {
25875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25876       };
25877     }
25878   }
25879
25880   jresult = (int)result;
25881   return jresult;
25882 }
25883
25884
25885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
25886   void * jresult ;
25887   Dali::Shader::Hint *result = 0 ;
25888
25889   {
25890     try {
25891       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
25892     } catch (std::out_of_range& e) {
25893       {
25894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25895       };
25896     } catch (std::exception& e) {
25897       {
25898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25899       };
25900     } catch (Dali::DaliException e) {
25901       {
25902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25903       };
25904     } catch (...) {
25905       {
25906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25907       };
25908     }
25909   }
25910
25911   jresult = (void *)result;
25912   return jresult;
25913 }
25914
25915
25916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
25917   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
25918
25919   arg1 = (Dali::Shader::Hint *)jarg1;
25920   {
25921     try {
25922       delete arg1;
25923     } catch (std::out_of_range& e) {
25924       {
25925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25926       };
25927     } catch (std::exception& e) {
25928       {
25929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25930       };
25931     } catch (Dali::DaliException e) {
25932       {
25933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25934       };
25935     } catch (...) {
25936       {
25937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25938       };
25939     }
25940   }
25941
25942 }
25943
25944
25945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
25946   int jresult ;
25947   int result;
25948
25949   result = (int)Dali::Shader::Property::PROGRAM;
25950   jresult = (int)result;
25951   return jresult;
25952 }
25953
25954
25955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
25956   void * jresult ;
25957   Dali::Shader::Property *result = 0 ;
25958
25959   {
25960     try {
25961       result = (Dali::Shader::Property *)new Dali::Shader::Property();
25962     } catch (std::out_of_range& e) {
25963       {
25964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25965       };
25966     } catch (std::exception& e) {
25967       {
25968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25969       };
25970     } catch (Dali::DaliException e) {
25971       {
25972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25973       };
25974     } catch (...) {
25975       {
25976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25977       };
25978     }
25979   }
25980
25981   jresult = (void *)result;
25982   return jresult;
25983 }
25984
25985
25986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
25987   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
25988
25989   arg1 = (Dali::Shader::Property *)jarg1;
25990   {
25991     try {
25992       delete arg1;
25993     } catch (std::out_of_range& e) {
25994       {
25995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25996       };
25997     } catch (std::exception& e) {
25998       {
25999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26000       };
26001     } catch (Dali::DaliException e) {
26002       {
26003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26004       };
26005     } catch (...) {
26006       {
26007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26008       };
26009     }
26010   }
26011
26012 }
26013
26014
26015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26016   void * jresult ;
26017   std::string *arg1 = 0 ;
26018   std::string *arg2 = 0 ;
26019   Dali::Shader::Hint::Value arg3 ;
26020   Dali::Shader result;
26021
26022   if (!jarg1) {
26023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26024     return 0;
26025   }
26026   std::string arg1_str(jarg1);
26027   arg1 = &arg1_str;
26028   if (!jarg2) {
26029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26030     return 0;
26031   }
26032   std::string arg2_str(jarg2);
26033   arg2 = &arg2_str;
26034   arg3 = (Dali::Shader::Hint::Value)jarg3;
26035   {
26036     try {
26037       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26038     } catch (std::out_of_range& e) {
26039       {
26040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26041       };
26042     } catch (std::exception& e) {
26043       {
26044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26045       };
26046     } catch (Dali::DaliException e) {
26047       {
26048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26049       };
26050     } catch (...) {
26051       {
26052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26053       };
26054     }
26055   }
26056
26057   jresult = new Dali::Shader((const Dali::Shader &)result);
26058
26059   //argout typemap for const std::string&
26060
26061
26062   //argout typemap for const std::string&
26063
26064   return jresult;
26065 }
26066
26067
26068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26069   void * jresult ;
26070   std::string *arg1 = 0 ;
26071   std::string *arg2 = 0 ;
26072   Dali::Shader result;
26073
26074   if (!jarg1) {
26075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26076     return 0;
26077   }
26078   std::string arg1_str(jarg1);
26079   arg1 = &arg1_str;
26080   if (!jarg2) {
26081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26082     return 0;
26083   }
26084   std::string arg2_str(jarg2);
26085   arg2 = &arg2_str;
26086   {
26087     try {
26088       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26089     } catch (std::out_of_range& e) {
26090       {
26091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26092       };
26093     } catch (std::exception& e) {
26094       {
26095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26096       };
26097     } catch (Dali::DaliException e) {
26098       {
26099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26100       };
26101     } catch (...) {
26102       {
26103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26104       };
26105     }
26106   }
26107
26108   jresult = new Dali::Shader((const Dali::Shader &)result);
26109
26110   //argout typemap for const std::string&
26111
26112
26113   //argout typemap for const std::string&
26114
26115   return jresult;
26116 }
26117
26118
26119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26120   void * jresult ;
26121   Dali::Shader *result = 0 ;
26122
26123   {
26124     try {
26125       result = (Dali::Shader *)new Dali::Shader();
26126     } catch (std::out_of_range& e) {
26127       {
26128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26129       };
26130     } catch (std::exception& e) {
26131       {
26132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26133       };
26134     } catch (Dali::DaliException e) {
26135       {
26136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26137       };
26138     } catch (...) {
26139       {
26140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26141       };
26142     }
26143   }
26144
26145   jresult = (void *)result;
26146   return jresult;
26147 }
26148
26149
26150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26151   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26152
26153   arg1 = (Dali::Shader *)jarg1;
26154   {
26155     try {
26156       delete arg1;
26157     } catch (std::out_of_range& e) {
26158       {
26159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26160       };
26161     } catch (std::exception& e) {
26162       {
26163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26164       };
26165     } catch (Dali::DaliException e) {
26166       {
26167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26168       };
26169     } catch (...) {
26170       {
26171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26172       };
26173     }
26174   }
26175
26176 }
26177
26178
26179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26180   void * jresult ;
26181   Dali::Shader *arg1 = 0 ;
26182   Dali::Shader *result = 0 ;
26183
26184   arg1 = (Dali::Shader *)jarg1;
26185   if (!arg1) {
26186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26187     return 0;
26188   }
26189   {
26190     try {
26191       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26192     } catch (std::out_of_range& e) {
26193       {
26194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26195       };
26196     } catch (std::exception& e) {
26197       {
26198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26199       };
26200     } catch (Dali::DaliException e) {
26201       {
26202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26203       };
26204     } catch (...) {
26205       {
26206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26207       };
26208     }
26209   }
26210
26211   jresult = (void *)result;
26212   return jresult;
26213 }
26214
26215
26216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26217   void * jresult ;
26218   Dali::BaseHandle arg1 ;
26219   Dali::BaseHandle *argp1 ;
26220   Dali::Shader result;
26221
26222   argp1 = (Dali::BaseHandle *)jarg1;
26223   if (!argp1) {
26224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26225     return 0;
26226   }
26227   arg1 = *argp1;
26228   {
26229     try {
26230       result = Dali::Shader::DownCast(arg1);
26231     } catch (std::out_of_range& e) {
26232       {
26233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26234       };
26235     } catch (std::exception& e) {
26236       {
26237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26238       };
26239     } catch (Dali::DaliException e) {
26240       {
26241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26242       };
26243     } catch (...) {
26244       {
26245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26246       };
26247     }
26248   }
26249
26250   jresult = new Dali::Shader((const Dali::Shader &)result);
26251   return jresult;
26252 }
26253
26254
26255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26256   void * jresult ;
26257   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26258   Dali::Shader *arg2 = 0 ;
26259   Dali::Shader *result = 0 ;
26260
26261   arg1 = (Dali::Shader *)jarg1;
26262   arg2 = (Dali::Shader *)jarg2;
26263   if (!arg2) {
26264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26265     return 0;
26266   }
26267   {
26268     try {
26269       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26270     } catch (std::out_of_range& e) {
26271       {
26272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26273       };
26274     } catch (std::exception& e) {
26275       {
26276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26277       };
26278     } catch (Dali::DaliException e) {
26279       {
26280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26281       };
26282     } catch (...) {
26283       {
26284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26285       };
26286     }
26287   }
26288
26289   jresult = (void *)result;
26290   return jresult;
26291 }
26292
26293
26294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
26295   int jresult ;
26296   int result;
26297
26298   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
26299   jresult = (int)result;
26300   return jresult;
26301 }
26302
26303
26304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
26305   int jresult ;
26306   int result;
26307
26308   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
26309   jresult = (int)result;
26310   return jresult;
26311 }
26312
26313
26314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
26315   int jresult ;
26316   int result;
26317
26318   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
26319   jresult = (int)result;
26320   return jresult;
26321 }
26322
26323
26324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
26325   int jresult ;
26326   int result;
26327
26328   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
26329   jresult = (int)result;
26330   return jresult;
26331 }
26332
26333
26334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
26335   int jresult ;
26336   int result;
26337
26338   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
26339   jresult = (int)result;
26340   return jresult;
26341 }
26342
26343
26344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26345   int jresult ;
26346   int result;
26347
26348   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26349   jresult = (int)result;
26350   return jresult;
26351 }
26352
26353
26354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26355   int jresult ;
26356   int result;
26357
26358   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26359   jresult = (int)result;
26360   return jresult;
26361 }
26362
26363
26364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26365   int jresult ;
26366   int result;
26367
26368   result = (int)Dali::Renderer::Property::BLEND_MODE;
26369   jresult = (int)result;
26370   return jresult;
26371 }
26372
26373
26374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26375   int jresult ;
26376   int result;
26377
26378   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26379   jresult = (int)result;
26380   return jresult;
26381 }
26382
26383
26384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26385   int jresult ;
26386   int result;
26387
26388   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26389   jresult = (int)result;
26390   return jresult;
26391 }
26392
26393
26394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26395   int jresult ;
26396   int result;
26397
26398   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26399   jresult = (int)result;
26400   return jresult;
26401 }
26402
26403
26404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26405   int jresult ;
26406   int result;
26407
26408   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26409   jresult = (int)result;
26410   return jresult;
26411 }
26412
26413
26414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26415   int jresult ;
26416   int result;
26417
26418   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26419   jresult = (int)result;
26420   return jresult;
26421 }
26422
26423
26424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26425   int jresult ;
26426   int result;
26427
26428   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26429   jresult = (int)result;
26430   return jresult;
26431 }
26432
26433
26434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26435   int jresult ;
26436   int result;
26437
26438   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26439   jresult = (int)result;
26440   return jresult;
26441 }
26442
26443
26444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26445   int jresult ;
26446   int result;
26447
26448   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26449   jresult = (int)result;
26450   return jresult;
26451 }
26452
26453
26454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26455   int jresult ;
26456   int result;
26457
26458   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26459   jresult = (int)result;
26460   return jresult;
26461 }
26462
26463
26464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26465   int jresult ;
26466   int result;
26467
26468   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26469   jresult = (int)result;
26470   return jresult;
26471 }
26472
26473
26474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26475   int jresult ;
26476   int result;
26477
26478   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26479   jresult = (int)result;
26480   return jresult;
26481 }
26482
26483
26484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26485   int jresult ;
26486   int result;
26487
26488   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26489   jresult = (int)result;
26490   return jresult;
26491 }
26492
26493
26494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26495   int jresult ;
26496   int result;
26497
26498   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26499   jresult = (int)result;
26500   return jresult;
26501 }
26502
26503
26504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26505   int jresult ;
26506   int result;
26507
26508   result = (int)Dali::Renderer::Property::RENDER_MODE;
26509   jresult = (int)result;
26510   return jresult;
26511 }
26512
26513
26514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26515   int jresult ;
26516   int result;
26517
26518   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26519   jresult = (int)result;
26520   return jresult;
26521 }
26522
26523
26524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26525   int jresult ;
26526   int result;
26527
26528   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26529   jresult = (int)result;
26530   return jresult;
26531 }
26532
26533
26534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26535   int jresult ;
26536   int result;
26537
26538   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26539   jresult = (int)result;
26540   return jresult;
26541 }
26542
26543
26544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26545   int jresult ;
26546   int result;
26547
26548   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26549   jresult = (int)result;
26550   return jresult;
26551 }
26552
26553
26554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26555   int jresult ;
26556   int result;
26557
26558   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26559   jresult = (int)result;
26560   return jresult;
26561 }
26562
26563
26564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26565   int jresult ;
26566   int result;
26567
26568   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26569   jresult = (int)result;
26570   return jresult;
26571 }
26572
26573
26574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26575   int jresult ;
26576   int result;
26577
26578   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26579   jresult = (int)result;
26580   return jresult;
26581 }
26582
26583
26584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26585   void * jresult ;
26586   Dali::Renderer::Property *result = 0 ;
26587
26588   {
26589     try {
26590       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26591     } catch (std::out_of_range& e) {
26592       {
26593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26594       };
26595     } catch (std::exception& e) {
26596       {
26597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26598       };
26599     } catch (Dali::DaliException e) {
26600       {
26601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26602       };
26603     } catch (...) {
26604       {
26605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26606       };
26607     }
26608   }
26609
26610   jresult = (void *)result;
26611   return jresult;
26612 }
26613
26614
26615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26616   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26617
26618   arg1 = (Dali::Renderer::Property *)jarg1;
26619   {
26620     try {
26621       delete arg1;
26622     } catch (std::out_of_range& e) {
26623       {
26624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26625       };
26626     } catch (std::exception& e) {
26627       {
26628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26629       };
26630     } catch (Dali::DaliException e) {
26631       {
26632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26633       };
26634     } catch (...) {
26635       {
26636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26637       };
26638     }
26639   }
26640
26641 }
26642
26643
26644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26645   void * jresult ;
26646   Dali::Geometry *arg1 = 0 ;
26647   Dali::Shader *arg2 = 0 ;
26648   Dali::Renderer result;
26649
26650   arg1 = (Dali::Geometry *)jarg1;
26651   if (!arg1) {
26652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26653     return 0;
26654   }
26655   arg2 = (Dali::Shader *)jarg2;
26656   if (!arg2) {
26657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26658     return 0;
26659   }
26660   {
26661     try {
26662       result = Dali::Renderer::New(*arg1,*arg2);
26663     } catch (std::out_of_range& e) {
26664       {
26665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26666       };
26667     } catch (std::exception& e) {
26668       {
26669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26670       };
26671     } catch (Dali::DaliException e) {
26672       {
26673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26674       };
26675     } catch (...) {
26676       {
26677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26678       };
26679     }
26680   }
26681
26682   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26683   return jresult;
26684 }
26685
26686
26687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26688   void * jresult ;
26689   Dali::Renderer *result = 0 ;
26690
26691   {
26692     try {
26693       result = (Dali::Renderer *)new Dali::Renderer();
26694     } catch (std::out_of_range& e) {
26695       {
26696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26697       };
26698     } catch (std::exception& e) {
26699       {
26700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26701       };
26702     } catch (Dali::DaliException e) {
26703       {
26704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26705       };
26706     } catch (...) {
26707       {
26708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26709       };
26710     }
26711   }
26712
26713   jresult = (void *)result;
26714   return jresult;
26715 }
26716
26717
26718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26719   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26720
26721   arg1 = (Dali::Renderer *)jarg1;
26722   {
26723     try {
26724       delete arg1;
26725     } catch (std::out_of_range& e) {
26726       {
26727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26728       };
26729     } catch (std::exception& e) {
26730       {
26731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26732       };
26733     } catch (Dali::DaliException e) {
26734       {
26735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26736       };
26737     } catch (...) {
26738       {
26739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26740       };
26741     }
26742   }
26743
26744 }
26745
26746
26747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26748   void * jresult ;
26749   Dali::Renderer *arg1 = 0 ;
26750   Dali::Renderer *result = 0 ;
26751
26752   arg1 = (Dali::Renderer *)jarg1;
26753   if (!arg1) {
26754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26755     return 0;
26756   }
26757   {
26758     try {
26759       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26760     } catch (std::out_of_range& e) {
26761       {
26762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26763       };
26764     } catch (std::exception& e) {
26765       {
26766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26767       };
26768     } catch (Dali::DaliException e) {
26769       {
26770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26771       };
26772     } catch (...) {
26773       {
26774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26775       };
26776     }
26777   }
26778
26779   jresult = (void *)result;
26780   return jresult;
26781 }
26782
26783
26784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26785   void * jresult ;
26786   Dali::BaseHandle arg1 ;
26787   Dali::BaseHandle *argp1 ;
26788   Dali::Renderer result;
26789
26790   argp1 = (Dali::BaseHandle *)jarg1;
26791   if (!argp1) {
26792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26793     return 0;
26794   }
26795   arg1 = *argp1;
26796   {
26797     try {
26798       result = Dali::Renderer::DownCast(arg1);
26799     } catch (std::out_of_range& e) {
26800       {
26801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26802       };
26803     } catch (std::exception& e) {
26804       {
26805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26806       };
26807     } catch (Dali::DaliException e) {
26808       {
26809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26810       };
26811     } catch (...) {
26812       {
26813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26814       };
26815     }
26816   }
26817
26818   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26819   return jresult;
26820 }
26821
26822
26823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
26824   void * jresult ;
26825   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26826   Dali::Renderer *arg2 = 0 ;
26827   Dali::Renderer *result = 0 ;
26828
26829   arg1 = (Dali::Renderer *)jarg1;
26830   arg2 = (Dali::Renderer *)jarg2;
26831   if (!arg2) {
26832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26833     return 0;
26834   }
26835   {
26836     try {
26837       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
26838     } catch (std::out_of_range& e) {
26839       {
26840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26841       };
26842     } catch (std::exception& e) {
26843       {
26844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26845       };
26846     } catch (Dali::DaliException e) {
26847       {
26848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26849       };
26850     } catch (...) {
26851       {
26852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26853       };
26854     }
26855   }
26856
26857   jresult = (void *)result;
26858   return jresult;
26859 }
26860
26861
26862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
26863   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26864   Dali::Geometry *arg2 = 0 ;
26865
26866   arg1 = (Dali::Renderer *)jarg1;
26867   arg2 = (Dali::Geometry *)jarg2;
26868   if (!arg2) {
26869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26870     return ;
26871   }
26872   {
26873     try {
26874       (arg1)->SetGeometry(*arg2);
26875     } catch (std::out_of_range& e) {
26876       {
26877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26878       };
26879     } catch (std::exception& e) {
26880       {
26881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26882       };
26883     } catch (Dali::DaliException e) {
26884       {
26885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26886       };
26887     } catch (...) {
26888       {
26889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26890       };
26891     }
26892   }
26893
26894 }
26895
26896
26897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
26898   void * jresult ;
26899   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26900   Dali::Geometry result;
26901
26902   arg1 = (Dali::Renderer *)jarg1;
26903   {
26904     try {
26905       result = ((Dali::Renderer const *)arg1)->GetGeometry();
26906     } catch (std::out_of_range& e) {
26907       {
26908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26909       };
26910     } catch (std::exception& e) {
26911       {
26912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26913       };
26914     } catch (Dali::DaliException e) {
26915       {
26916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26917       };
26918     } catch (...) {
26919       {
26920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26921       };
26922     }
26923   }
26924
26925   jresult = new Dali::Geometry((const Dali::Geometry &)result);
26926   return jresult;
26927 }
26928
26929
26930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
26931   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26932   int arg2 ;
26933   int arg3 ;
26934
26935   arg1 = (Dali::Renderer *)jarg1;
26936   arg2 = (int)jarg2;
26937   arg3 = (int)jarg3;
26938   {
26939     try {
26940       (arg1)->SetIndexRange(arg2,arg3);
26941     } catch (std::out_of_range& e) {
26942       {
26943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26944       };
26945     } catch (std::exception& e) {
26946       {
26947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26948       };
26949     } catch (Dali::DaliException e) {
26950       {
26951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26952       };
26953     } catch (...) {
26954       {
26955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26956       };
26957     }
26958   }
26959
26960 }
26961
26962
26963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
26964   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26965   Dali::TextureSet *arg2 = 0 ;
26966
26967   arg1 = (Dali::Renderer *)jarg1;
26968   arg2 = (Dali::TextureSet *)jarg2;
26969   if (!arg2) {
26970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
26971     return ;
26972   }
26973   {
26974     try {
26975       (arg1)->SetTextures(*arg2);
26976     } catch (std::out_of_range& e) {
26977       {
26978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26979       };
26980     } catch (std::exception& e) {
26981       {
26982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26983       };
26984     } catch (Dali::DaliException e) {
26985       {
26986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26987       };
26988     } catch (...) {
26989       {
26990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26991       };
26992     }
26993   }
26994
26995 }
26996
26997
26998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
26999   void * jresult ;
27000   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27001   Dali::TextureSet result;
27002
27003   arg1 = (Dali::Renderer *)jarg1;
27004   {
27005     try {
27006       result = ((Dali::Renderer const *)arg1)->GetTextures();
27007     } catch (std::out_of_range& e) {
27008       {
27009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27010       };
27011     } catch (std::exception& e) {
27012       {
27013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27014       };
27015     } catch (Dali::DaliException e) {
27016       {
27017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27018       };
27019     } catch (...) {
27020       {
27021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27022       };
27023     }
27024   }
27025
27026   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27027   return jresult;
27028 }
27029
27030
27031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27032   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27033   Dali::Shader *arg2 = 0 ;
27034
27035   arg1 = (Dali::Renderer *)jarg1;
27036   arg2 = (Dali::Shader *)jarg2;
27037   if (!arg2) {
27038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27039     return ;
27040   }
27041   {
27042     try {
27043       (arg1)->SetShader(*arg2);
27044     } catch (std::out_of_range& e) {
27045       {
27046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27047       };
27048     } catch (std::exception& e) {
27049       {
27050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27051       };
27052     } catch (Dali::DaliException e) {
27053       {
27054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27055       };
27056     } catch (...) {
27057       {
27058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27059       };
27060     }
27061   }
27062
27063 }
27064
27065
27066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27067   void * jresult ;
27068   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27069   Dali::Shader result;
27070
27071   arg1 = (Dali::Renderer *)jarg1;
27072   {
27073     try {
27074       result = ((Dali::Renderer const *)arg1)->GetShader();
27075     } catch (std::out_of_range& e) {
27076       {
27077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27078       };
27079     } catch (std::exception& e) {
27080       {
27081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27082       };
27083     } catch (Dali::DaliException e) {
27084       {
27085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27086       };
27087     } catch (...) {
27088       {
27089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27090       };
27091     }
27092   }
27093
27094   jresult = new Dali::Shader((const Dali::Shader &)result);
27095   return jresult;
27096 }
27097
27098
27099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27100   void * jresult ;
27101   Dali::FrameBuffer::Attachment *result = 0 ;
27102
27103   {
27104     try {
27105       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27106     } catch (std::out_of_range& e) {
27107       {
27108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27109       };
27110     } catch (std::exception& e) {
27111       {
27112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27113       };
27114     } catch (Dali::DaliException e) {
27115       {
27116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27117       };
27118     } catch (...) {
27119       {
27120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27121       };
27122     }
27123   }
27124
27125   jresult = (void *)result;
27126   return jresult;
27127 }
27128
27129
27130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27131   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27132
27133   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27134   {
27135     try {
27136       delete arg1;
27137     } catch (std::out_of_range& e) {
27138       {
27139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27140       };
27141     } catch (std::exception& e) {
27142       {
27143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27144       };
27145     } catch (Dali::DaliException e) {
27146       {
27147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27148       };
27149     } catch (...) {
27150       {
27151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27152       };
27153     }
27154   }
27155
27156 }
27157
27158
27159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27160   void * jresult ;
27161   unsigned int arg1 ;
27162   unsigned int arg2 ;
27163   unsigned int arg3 ;
27164   Dali::FrameBuffer result;
27165
27166   arg1 = (unsigned int)jarg1;
27167   arg2 = (unsigned int)jarg2;
27168   arg3 = (unsigned int)jarg3;
27169   {
27170     try {
27171       result = Dali::FrameBuffer::New(arg1,arg2,static_cast<Dali::FrameBuffer::Attachment::Mask>(arg3));
27172     } catch (std::out_of_range& e) {
27173       {
27174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27175       };
27176     } catch (std::exception& e) {
27177       {
27178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27179       };
27180     } catch (Dali::DaliException e) {
27181       {
27182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27183       };
27184     } catch (...) {
27185       {
27186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27187       };
27188     }
27189   }
27190
27191   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27192   return jresult;
27193 }
27194
27195
27196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27197   void * jresult ;
27198   Dali::FrameBuffer *result = 0 ;
27199
27200   {
27201     try {
27202       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27203     } catch (std::out_of_range& e) {
27204       {
27205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27206       };
27207     } catch (std::exception& e) {
27208       {
27209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27210       };
27211     } catch (Dali::DaliException e) {
27212       {
27213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27214       };
27215     } catch (...) {
27216       {
27217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27218       };
27219     }
27220   }
27221
27222   jresult = (void *)result;
27223   return jresult;
27224 }
27225
27226
27227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27228   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27229
27230   arg1 = (Dali::FrameBuffer *)jarg1;
27231   {
27232     try {
27233       delete arg1;
27234     } catch (std::out_of_range& e) {
27235       {
27236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27237       };
27238     } catch (std::exception& e) {
27239       {
27240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27241       };
27242     } catch (Dali::DaliException e) {
27243       {
27244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27245       };
27246     } catch (...) {
27247       {
27248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27249       };
27250     }
27251   }
27252
27253 }
27254
27255
27256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27257   void * jresult ;
27258   Dali::FrameBuffer *arg1 = 0 ;
27259   Dali::FrameBuffer *result = 0 ;
27260
27261   arg1 = (Dali::FrameBuffer *)jarg1;
27262   if (!arg1) {
27263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27264     return 0;
27265   }
27266   {
27267     try {
27268       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27269     } catch (std::out_of_range& e) {
27270       {
27271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27272       };
27273     } catch (std::exception& e) {
27274       {
27275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27276       };
27277     } catch (Dali::DaliException e) {
27278       {
27279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27280       };
27281     } catch (...) {
27282       {
27283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27284       };
27285     }
27286   }
27287
27288   jresult = (void *)result;
27289   return jresult;
27290 }
27291
27292
27293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27294   void * jresult ;
27295   Dali::BaseHandle arg1 ;
27296   Dali::BaseHandle *argp1 ;
27297   Dali::FrameBuffer result;
27298
27299   argp1 = (Dali::BaseHandle *)jarg1;
27300   if (!argp1) {
27301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27302     return 0;
27303   }
27304   arg1 = *argp1;
27305   {
27306     try {
27307       result = Dali::FrameBuffer::DownCast(arg1);
27308     } catch (std::out_of_range& e) {
27309       {
27310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27311       };
27312     } catch (std::exception& e) {
27313       {
27314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27315       };
27316     } catch (Dali::DaliException e) {
27317       {
27318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27319       };
27320     } catch (...) {
27321       {
27322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27323       };
27324     }
27325   }
27326
27327   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27328   return jresult;
27329 }
27330
27331
27332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27333   void * jresult ;
27334   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27335   Dali::FrameBuffer *arg2 = 0 ;
27336   Dali::FrameBuffer *result = 0 ;
27337
27338   arg1 = (Dali::FrameBuffer *)jarg1;
27339   arg2 = (Dali::FrameBuffer *)jarg2;
27340   if (!arg2) {
27341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27342     return 0;
27343   }
27344   {
27345     try {
27346       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27347     } catch (std::out_of_range& e) {
27348       {
27349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27350       };
27351     } catch (std::exception& e) {
27352       {
27353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27354       };
27355     } catch (Dali::DaliException e) {
27356       {
27357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27358       };
27359     } catch (...) {
27360       {
27361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27362       };
27363     }
27364   }
27365
27366   jresult = (void *)result;
27367   return jresult;
27368 }
27369
27370
27371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27372   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27373   Dali::Texture *arg2 = 0 ;
27374
27375   arg1 = (Dali::FrameBuffer *)jarg1;
27376   arg2 = (Dali::Texture *)jarg2;
27377   if (!arg2) {
27378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27379     return ;
27380   }
27381   {
27382     try {
27383       (arg1)->AttachColorTexture(*arg2);
27384     } catch (std::out_of_range& e) {
27385       {
27386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27387       };
27388     } catch (std::exception& e) {
27389       {
27390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27391       };
27392     } catch (Dali::DaliException e) {
27393       {
27394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27395       };
27396     } catch (...) {
27397       {
27398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27399       };
27400     }
27401   }
27402
27403 }
27404
27405
27406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27407   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27408   Dali::Texture *arg2 = 0 ;
27409   unsigned int arg3 ;
27410   unsigned int arg4 ;
27411
27412   arg1 = (Dali::FrameBuffer *)jarg1;
27413   arg2 = (Dali::Texture *)jarg2;
27414   if (!arg2) {
27415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27416     return ;
27417   }
27418   arg3 = (unsigned int)jarg3;
27419   arg4 = (unsigned int)jarg4;
27420   {
27421     try {
27422       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27423     } catch (std::out_of_range& e) {
27424       {
27425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27426       };
27427     } catch (std::exception& e) {
27428       {
27429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27430       };
27431     } catch (Dali::DaliException e) {
27432       {
27433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27434       };
27435     } catch (...) {
27436       {
27437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27438       };
27439     }
27440   }
27441
27442 }
27443
27444
27445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27446   void * jresult ;
27447   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27448   Dali::Texture result;
27449
27450   arg1 = (Dali::FrameBuffer *)jarg1;
27451   {
27452     try {
27453       result = (arg1)->GetColorTexture();
27454     } catch (std::out_of_range& e) {
27455       {
27456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27457       };
27458     } catch (std::exception& e) {
27459       {
27460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27461       };
27462     } catch (Dali::DaliException e) {
27463       {
27464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27465       };
27466     } catch (...) {
27467       {
27468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27469       };
27470     }
27471   }
27472
27473   jresult = new Dali::Texture((const Dali::Texture &)result);
27474   return jresult;
27475 }
27476
27477
27478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27479   void * jresult ;
27480   Dali::RenderTaskList *result = 0 ;
27481
27482   {
27483     try {
27484       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27485     } catch (std::out_of_range& e) {
27486       {
27487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27488       };
27489     } catch (std::exception& e) {
27490       {
27491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27492       };
27493     } catch (Dali::DaliException e) {
27494       {
27495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27496       };
27497     } catch (...) {
27498       {
27499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27500       };
27501     }
27502   }
27503
27504   jresult = (void *)result;
27505   return jresult;
27506 }
27507
27508
27509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27510   void * jresult ;
27511   Dali::BaseHandle arg1 ;
27512   Dali::BaseHandle *argp1 ;
27513   Dali::RenderTaskList result;
27514
27515   argp1 = (Dali::BaseHandle *)jarg1;
27516   if (!argp1) {
27517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27518     return 0;
27519   }
27520   arg1 = *argp1;
27521   {
27522     try {
27523       result = Dali::RenderTaskList::DownCast(arg1);
27524     } catch (std::out_of_range& e) {
27525       {
27526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27527       };
27528     } catch (std::exception& e) {
27529       {
27530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27531       };
27532     } catch (Dali::DaliException e) {
27533       {
27534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27535       };
27536     } catch (...) {
27537       {
27538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27539       };
27540     }
27541   }
27542
27543   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27544   return jresult;
27545 }
27546
27547
27548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27549   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27550
27551   arg1 = (Dali::RenderTaskList *)jarg1;
27552   {
27553     try {
27554       delete arg1;
27555     } catch (std::out_of_range& e) {
27556       {
27557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27558       };
27559     } catch (std::exception& e) {
27560       {
27561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27562       };
27563     } catch (Dali::DaliException e) {
27564       {
27565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27566       };
27567     } catch (...) {
27568       {
27569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27570       };
27571     }
27572   }
27573
27574 }
27575
27576
27577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27578   void * jresult ;
27579   Dali::RenderTaskList *arg1 = 0 ;
27580   Dali::RenderTaskList *result = 0 ;
27581
27582   arg1 = (Dali::RenderTaskList *)jarg1;
27583   if (!arg1) {
27584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27585     return 0;
27586   }
27587   {
27588     try {
27589       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27590     } catch (std::out_of_range& e) {
27591       {
27592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27593       };
27594     } catch (std::exception& e) {
27595       {
27596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27597       };
27598     } catch (Dali::DaliException e) {
27599       {
27600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27601       };
27602     } catch (...) {
27603       {
27604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27605       };
27606     }
27607   }
27608
27609   jresult = (void *)result;
27610   return jresult;
27611 }
27612
27613
27614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27615   void * jresult ;
27616   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27617   Dali::RenderTaskList *arg2 = 0 ;
27618   Dali::RenderTaskList *result = 0 ;
27619
27620   arg1 = (Dali::RenderTaskList *)jarg1;
27621   arg2 = (Dali::RenderTaskList *)jarg2;
27622   if (!arg2) {
27623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27624     return 0;
27625   }
27626   {
27627     try {
27628       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27629     } catch (std::out_of_range& e) {
27630       {
27631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27632       };
27633     } catch (std::exception& e) {
27634       {
27635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27636       };
27637     } catch (Dali::DaliException e) {
27638       {
27639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27640       };
27641     } catch (...) {
27642       {
27643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27644       };
27645     }
27646   }
27647
27648   jresult = (void *)result;
27649   return jresult;
27650 }
27651
27652
27653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27654   void * jresult ;
27655   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27656   Dali::RenderTask result;
27657
27658   arg1 = (Dali::RenderTaskList *)jarg1;
27659   {
27660     try {
27661       result = (arg1)->CreateTask();
27662     } catch (std::out_of_range& e) {
27663       {
27664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27665       };
27666     } catch (std::exception& e) {
27667       {
27668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27669       };
27670     } catch (Dali::DaliException e) {
27671       {
27672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27673       };
27674     } catch (...) {
27675       {
27676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27677       };
27678     }
27679   }
27680
27681   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27682   return jresult;
27683 }
27684
27685
27686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27687   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27688   Dali::RenderTask arg2 ;
27689   Dali::RenderTask *argp2 ;
27690
27691   arg1 = (Dali::RenderTaskList *)jarg1;
27692   argp2 = (Dali::RenderTask *)jarg2;
27693   if (!argp2) {
27694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27695     return ;
27696   }
27697   arg2 = *argp2;
27698   {
27699     try {
27700       (arg1)->RemoveTask(arg2);
27701     } catch (std::out_of_range& e) {
27702       {
27703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27704       };
27705     } catch (std::exception& e) {
27706       {
27707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27708       };
27709     } catch (Dali::DaliException e) {
27710       {
27711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27712       };
27713     } catch (...) {
27714       {
27715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27716       };
27717     }
27718   }
27719
27720 }
27721
27722
27723 //// ===============================================end part 1 =================
27724
27725 //// ========================= part 2 ===============================
27726
27727 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27728   unsigned int jresult ;
27729   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27730   unsigned int result;
27731
27732   arg1 = (Dali::RenderTaskList *)jarg1;
27733   {
27734     try {
27735       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27736     } catch (std::out_of_range& e) {
27737       {
27738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27739       };
27740     } catch (std::exception& e) {
27741       {
27742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27743       };
27744     } catch (Dali::DaliException e) {
27745       {
27746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27747       };
27748     } catch (...) {
27749       {
27750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27751       };
27752     }
27753   }
27754
27755   jresult = result;
27756   return jresult;
27757 }
27758
27759
27760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27761   void * jresult ;
27762   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27763   unsigned int arg2 ;
27764   Dali::RenderTask result;
27765
27766   arg1 = (Dali::RenderTaskList *)jarg1;
27767   arg2 = (unsigned int)jarg2;
27768   {
27769     try {
27770       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27771     } catch (std::out_of_range& e) {
27772       {
27773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27774       };
27775     } catch (std::exception& e) {
27776       {
27777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27778       };
27779     } catch (Dali::DaliException e) {
27780       {
27781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27782       };
27783     } catch (...) {
27784       {
27785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27786       };
27787     }
27788   }
27789
27790   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27791   return jresult;
27792 }
27793
27794
27795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27796   int jresult ;
27797   int result;
27798
27799   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27800   jresult = (int)result;
27801   return jresult;
27802 }
27803
27804
27805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27806   int jresult ;
27807   int result;
27808
27809   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27810   jresult = (int)result;
27811   return jresult;
27812 }
27813
27814
27815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
27816   int jresult ;
27817   int result;
27818
27819   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
27820   jresult = (int)result;
27821   return jresult;
27822 }
27823
27824
27825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
27826   int jresult ;
27827   int result;
27828
27829   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
27830   jresult = (int)result;
27831   return jresult;
27832 }
27833
27834
27835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
27836   void * jresult ;
27837   Dali::RenderTask::Property *result = 0 ;
27838
27839   {
27840     try {
27841       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
27842     } catch (std::out_of_range& e) {
27843       {
27844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27845       };
27846     } catch (std::exception& e) {
27847       {
27848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27849       };
27850     } catch (Dali::DaliException e) {
27851       {
27852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27853       };
27854     } catch (...) {
27855       {
27856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27857       };
27858     }
27859   }
27860
27861   jresult = (void *)result;
27862   return jresult;
27863 }
27864
27865
27866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
27867   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
27868
27869   arg1 = (Dali::RenderTask::Property *)jarg1;
27870   {
27871     try {
27872       delete arg1;
27873     } catch (std::out_of_range& e) {
27874       {
27875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27876       };
27877     } catch (std::exception& e) {
27878       {
27879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27880       };
27881     } catch (Dali::DaliException e) {
27882       {
27883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27884       };
27885     } catch (...) {
27886       {
27887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27888       };
27889     }
27890   }
27891
27892 }
27893
27894
27895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
27896   void * jresult ;
27897   bool (*result)(Dali::Vector2 &) = 0 ;
27898
27899   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
27900   jresult = (void *)result;
27901   return jresult;
27902 }
27903
27904
27905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
27906   void * jresult ;
27907   bool (*result)(Dali::Vector2 &) = 0 ;
27908
27909   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
27910   jresult = (void *)result;
27911   return jresult;
27912 }
27913
27914
27915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
27916   unsigned int jresult ;
27917   bool result;
27918
27919   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
27920   jresult = result;
27921   return jresult;
27922 }
27923
27924
27925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
27926   unsigned int jresult ;
27927   bool result;
27928
27929   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
27930   jresult = result;
27931   return jresult;
27932 }
27933
27934
27935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
27936   void * jresult ;
27937   Dali::Vector4 *result = 0 ;
27938
27939   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
27940   jresult = (void *)result;
27941   return jresult;
27942 }
27943
27944
27945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
27946   unsigned int jresult ;
27947   bool result;
27948
27949   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
27950   jresult = result;
27951   return jresult;
27952 }
27953
27954
27955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
27956   unsigned int jresult ;
27957   bool result;
27958
27959   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
27960   jresult = result;
27961   return jresult;
27962 }
27963
27964
27965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
27966   unsigned int jresult ;
27967   unsigned int result;
27968
27969   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
27970   jresult = result;
27971   return jresult;
27972 }
27973
27974
27975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
27976   void * jresult ;
27977   Dali::RenderTask *result = 0 ;
27978
27979   {
27980     try {
27981       result = (Dali::RenderTask *)new Dali::RenderTask();
27982     } catch (std::out_of_range& e) {
27983       {
27984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27985       };
27986     } catch (std::exception& e) {
27987       {
27988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27989       };
27990     } catch (Dali::DaliException e) {
27991       {
27992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27993       };
27994     } catch (...) {
27995       {
27996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27997       };
27998     }
27999   }
28000
28001   jresult = (void *)result;
28002   return jresult;
28003 }
28004
28005
28006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28007   void * jresult ;
28008   Dali::BaseHandle arg1 ;
28009   Dali::BaseHandle *argp1 ;
28010   Dali::RenderTask result;
28011
28012   argp1 = (Dali::BaseHandle *)jarg1;
28013   if (!argp1) {
28014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28015     return 0;
28016   }
28017   arg1 = *argp1;
28018   {
28019     try {
28020       result = Dali::RenderTask::DownCast(arg1);
28021     } catch (std::out_of_range& e) {
28022       {
28023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28024       };
28025     } catch (std::exception& e) {
28026       {
28027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28028       };
28029     } catch (Dali::DaliException e) {
28030       {
28031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28032       };
28033     } catch (...) {
28034       {
28035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28036       };
28037     }
28038   }
28039
28040   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28041   return jresult;
28042 }
28043
28044
28045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28046   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28047
28048   arg1 = (Dali::RenderTask *)jarg1;
28049   {
28050     try {
28051       delete arg1;
28052     } catch (std::out_of_range& e) {
28053       {
28054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28055       };
28056     } catch (std::exception& e) {
28057       {
28058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28059       };
28060     } catch (Dali::DaliException e) {
28061       {
28062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28063       };
28064     } catch (...) {
28065       {
28066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28067       };
28068     }
28069   }
28070
28071 }
28072
28073
28074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28075   void * jresult ;
28076   Dali::RenderTask *arg1 = 0 ;
28077   Dali::RenderTask *result = 0 ;
28078
28079   arg1 = (Dali::RenderTask *)jarg1;
28080   if (!arg1) {
28081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28082     return 0;
28083   }
28084   {
28085     try {
28086       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28087     } catch (std::out_of_range& e) {
28088       {
28089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28090       };
28091     } catch (std::exception& e) {
28092       {
28093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28094       };
28095     } catch (Dali::DaliException e) {
28096       {
28097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28098       };
28099     } catch (...) {
28100       {
28101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28102       };
28103     }
28104   }
28105
28106   jresult = (void *)result;
28107   return jresult;
28108 }
28109
28110
28111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28112   void * jresult ;
28113   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28114   Dali::RenderTask *arg2 = 0 ;
28115   Dali::RenderTask *result = 0 ;
28116
28117   arg1 = (Dali::RenderTask *)jarg1;
28118   arg2 = (Dali::RenderTask *)jarg2;
28119   if (!arg2) {
28120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28121     return 0;
28122   }
28123   {
28124     try {
28125       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28126     } catch (std::out_of_range& e) {
28127       {
28128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28129       };
28130     } catch (std::exception& e) {
28131       {
28132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28133       };
28134     } catch (Dali::DaliException e) {
28135       {
28136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28137       };
28138     } catch (...) {
28139       {
28140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28141       };
28142     }
28143   }
28144
28145   jresult = (void *)result;
28146   return jresult;
28147 }
28148
28149
28150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28151   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28152   Dali::Actor arg2 ;
28153   Dali::Actor *argp2 ;
28154
28155   arg1 = (Dali::RenderTask *)jarg1;
28156   argp2 = (Dali::Actor *)jarg2;
28157   if (!argp2) {
28158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28159     return ;
28160   }
28161   arg2 = *argp2;
28162   {
28163     try {
28164       (arg1)->SetSourceActor(arg2);
28165     } catch (std::out_of_range& e) {
28166       {
28167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28168       };
28169     } catch (std::exception& e) {
28170       {
28171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28172       };
28173     } catch (Dali::DaliException e) {
28174       {
28175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28176       };
28177     } catch (...) {
28178       {
28179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28180       };
28181     }
28182   }
28183
28184 }
28185
28186
28187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28188   void * jresult ;
28189   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28190   Dali::Actor result;
28191
28192   arg1 = (Dali::RenderTask *)jarg1;
28193   {
28194     try {
28195       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28196     } catch (std::out_of_range& e) {
28197       {
28198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28199       };
28200     } catch (std::exception& e) {
28201       {
28202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28203       };
28204     } catch (Dali::DaliException e) {
28205       {
28206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28207       };
28208     } catch (...) {
28209       {
28210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28211       };
28212     }
28213   }
28214
28215   jresult = new Dali::Actor((const Dali::Actor &)result);
28216   return jresult;
28217 }
28218
28219
28220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28221   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28222   bool arg2 ;
28223
28224   arg1 = (Dali::RenderTask *)jarg1;
28225   arg2 = jarg2 ? true : false;
28226   {
28227     try {
28228       (arg1)->SetExclusive(arg2);
28229     } catch (std::out_of_range& e) {
28230       {
28231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28232       };
28233     } catch (std::exception& e) {
28234       {
28235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28236       };
28237     } catch (Dali::DaliException e) {
28238       {
28239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28240       };
28241     } catch (...) {
28242       {
28243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28244       };
28245     }
28246   }
28247
28248 }
28249
28250
28251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28252   unsigned int jresult ;
28253   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28254   bool result;
28255
28256   arg1 = (Dali::RenderTask *)jarg1;
28257   {
28258     try {
28259       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28260     } catch (std::out_of_range& e) {
28261       {
28262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28263       };
28264     } catch (std::exception& e) {
28265       {
28266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28267       };
28268     } catch (Dali::DaliException e) {
28269       {
28270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28271       };
28272     } catch (...) {
28273       {
28274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28275       };
28276     }
28277   }
28278
28279   jresult = result;
28280   return jresult;
28281 }
28282
28283
28284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28285   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28286   bool arg2 ;
28287
28288   arg1 = (Dali::RenderTask *)jarg1;
28289   arg2 = jarg2 ? true : false;
28290   {
28291     try {
28292       (arg1)->SetInputEnabled(arg2);
28293     } catch (std::out_of_range& e) {
28294       {
28295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28296       };
28297     } catch (std::exception& e) {
28298       {
28299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28300       };
28301     } catch (Dali::DaliException e) {
28302       {
28303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28304       };
28305     } catch (...) {
28306       {
28307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28308       };
28309     }
28310   }
28311
28312 }
28313
28314
28315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28316   unsigned int jresult ;
28317   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28318   bool result;
28319
28320   arg1 = (Dali::RenderTask *)jarg1;
28321   {
28322     try {
28323       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28324     } catch (std::out_of_range& e) {
28325       {
28326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28327       };
28328     } catch (std::exception& e) {
28329       {
28330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28331       };
28332     } catch (Dali::DaliException e) {
28333       {
28334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28335       };
28336     } catch (...) {
28337       {
28338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28339       };
28340     }
28341   }
28342
28343   jresult = result;
28344   return jresult;
28345 }
28346
28347
28348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28349   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28350   Dali::CameraActor arg2 ;
28351   Dali::CameraActor *argp2 ;
28352
28353   arg1 = (Dali::RenderTask *)jarg1;
28354   argp2 = (Dali::CameraActor *)jarg2;
28355   if (!argp2) {
28356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28357     return ;
28358   }
28359   arg2 = *argp2;
28360   {
28361     try {
28362       (arg1)->SetCameraActor(arg2);
28363     } catch (std::out_of_range& e) {
28364       {
28365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28366       };
28367     } catch (std::exception& e) {
28368       {
28369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28370       };
28371     } catch (Dali::DaliException e) {
28372       {
28373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28374       };
28375     } catch (...) {
28376       {
28377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28378       };
28379     }
28380   }
28381
28382 }
28383
28384
28385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28386   void * jresult ;
28387   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28388   Dali::CameraActor result;
28389
28390   arg1 = (Dali::RenderTask *)jarg1;
28391   {
28392     try {
28393       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28394     } catch (std::out_of_range& e) {
28395       {
28396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28397       };
28398     } catch (std::exception& e) {
28399       {
28400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28401       };
28402     } catch (Dali::DaliException e) {
28403       {
28404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28405       };
28406     } catch (...) {
28407       {
28408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28409       };
28410     }
28411   }
28412
28413   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28414   return jresult;
28415 }
28416
28417
28418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28419   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28420   Dali::FrameBuffer arg2 ;
28421   Dali::FrameBuffer *argp2 ;
28422
28423   arg1 = (Dali::RenderTask *)jarg1;
28424   argp2 = (Dali::FrameBuffer *)jarg2;
28425   if (!argp2) {
28426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28427     return ;
28428   }
28429   arg2 = *argp2;
28430   {
28431     try {
28432       (arg1)->SetFrameBuffer(arg2);
28433     } catch (std::out_of_range& e) {
28434       {
28435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28436       };
28437     } catch (std::exception& e) {
28438       {
28439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28440       };
28441     } catch (Dali::DaliException e) {
28442       {
28443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28444       };
28445     } catch (...) {
28446       {
28447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28448       };
28449     }
28450   }
28451
28452 }
28453
28454
28455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28456   void * jresult ;
28457   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28458   Dali::FrameBuffer result;
28459
28460   arg1 = (Dali::RenderTask *)jarg1;
28461   {
28462     try {
28463       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28464     } catch (std::out_of_range& e) {
28465       {
28466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28467       };
28468     } catch (std::exception& e) {
28469       {
28470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28471       };
28472     } catch (Dali::DaliException e) {
28473       {
28474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28475       };
28476     } catch (...) {
28477       {
28478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28479       };
28480     }
28481   }
28482
28483   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28484   return jresult;
28485 }
28486
28487
28488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28489   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28490   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28491
28492   arg1 = (Dali::RenderTask *)jarg1;
28493   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28494   {
28495     try {
28496       (arg1)->SetScreenToFrameBufferFunction(arg2);
28497     } catch (std::out_of_range& e) {
28498       {
28499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28500       };
28501     } catch (std::exception& e) {
28502       {
28503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28504       };
28505     } catch (Dali::DaliException e) {
28506       {
28507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28508       };
28509     } catch (...) {
28510       {
28511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28512       };
28513     }
28514   }
28515
28516 }
28517
28518
28519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28520   void * jresult ;
28521   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28522   Dali::RenderTask::ScreenToFrameBufferFunction result;
28523
28524   arg1 = (Dali::RenderTask *)jarg1;
28525   {
28526     try {
28527       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28528     } catch (std::out_of_range& e) {
28529       {
28530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28531       };
28532     } catch (std::exception& e) {
28533       {
28534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28535       };
28536     } catch (Dali::DaliException e) {
28537       {
28538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28539       };
28540     } catch (...) {
28541       {
28542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28543       };
28544     }
28545   }
28546
28547   jresult = (void *)result;
28548   return jresult;
28549 }
28550
28551
28552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28553   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28554   Dali::Actor arg2 ;
28555   Dali::Actor *argp2 ;
28556
28557   arg1 = (Dali::RenderTask *)jarg1;
28558   argp2 = (Dali::Actor *)jarg2;
28559   if (!argp2) {
28560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28561     return ;
28562   }
28563   arg2 = *argp2;
28564   {
28565     try {
28566       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28567     } catch (std::out_of_range& e) {
28568       {
28569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28570       };
28571     } catch (std::exception& e) {
28572       {
28573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28574       };
28575     } catch (Dali::DaliException e) {
28576       {
28577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28578       };
28579     } catch (...) {
28580       {
28581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28582       };
28583     }
28584   }
28585
28586 }
28587
28588
28589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28590   void * jresult ;
28591   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28592   Dali::Actor result;
28593
28594   arg1 = (Dali::RenderTask *)jarg1;
28595   {
28596     try {
28597       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28598     } catch (std::out_of_range& e) {
28599       {
28600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28601       };
28602     } catch (std::exception& e) {
28603       {
28604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28605       };
28606     } catch (Dali::DaliException e) {
28607       {
28608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28609       };
28610     } catch (...) {
28611       {
28612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28613       };
28614     }
28615   }
28616
28617   jresult = new Dali::Actor((const Dali::Actor &)result);
28618   return jresult;
28619 }
28620
28621
28622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28623   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28624   Dali::Vector2 arg2 ;
28625   Dali::Vector2 *argp2 ;
28626
28627   arg1 = (Dali::RenderTask *)jarg1;
28628   argp2 = (Dali::Vector2 *)jarg2;
28629   if (!argp2) {
28630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28631     return ;
28632   }
28633   arg2 = *argp2;
28634   {
28635     try {
28636       (arg1)->SetViewportPosition(arg2);
28637     } catch (std::out_of_range& e) {
28638       {
28639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28640       };
28641     } catch (std::exception& e) {
28642       {
28643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28644       };
28645     } catch (Dali::DaliException e) {
28646       {
28647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28648       };
28649     } catch (...) {
28650       {
28651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28652       };
28653     }
28654   }
28655
28656 }
28657
28658
28659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28660   void * jresult ;
28661   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28662   Dali::Vector2 result;
28663
28664   arg1 = (Dali::RenderTask *)jarg1;
28665   {
28666     try {
28667       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28668     } catch (std::out_of_range& e) {
28669       {
28670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28671       };
28672     } catch (std::exception& e) {
28673       {
28674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28675       };
28676     } catch (Dali::DaliException e) {
28677       {
28678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28679       };
28680     } catch (...) {
28681       {
28682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28683       };
28684     }
28685   }
28686
28687   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28688   return jresult;
28689 }
28690
28691
28692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28693   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28694   Dali::Vector2 arg2 ;
28695   Dali::Vector2 *argp2 ;
28696
28697   arg1 = (Dali::RenderTask *)jarg1;
28698   argp2 = (Dali::Vector2 *)jarg2;
28699   if (!argp2) {
28700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28701     return ;
28702   }
28703   arg2 = *argp2;
28704   {
28705     try {
28706       (arg1)->SetViewportSize(arg2);
28707     } catch (std::out_of_range& e) {
28708       {
28709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28710       };
28711     } catch (std::exception& e) {
28712       {
28713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28714       };
28715     } catch (Dali::DaliException e) {
28716       {
28717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28718       };
28719     } catch (...) {
28720       {
28721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28722       };
28723     }
28724   }
28725
28726 }
28727
28728
28729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28730   void * jresult ;
28731   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28732   Dali::Vector2 result;
28733
28734   arg1 = (Dali::RenderTask *)jarg1;
28735   {
28736     try {
28737       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28738     } catch (std::out_of_range& e) {
28739       {
28740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28741       };
28742     } catch (std::exception& e) {
28743       {
28744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28745       };
28746     } catch (Dali::DaliException e) {
28747       {
28748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28749       };
28750     } catch (...) {
28751       {
28752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28753       };
28754     }
28755   }
28756
28757   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28758   return jresult;
28759 }
28760
28761
28762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
28763   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28764   Dali::Viewport arg2 ;
28765   Dali::Viewport *argp2 ;
28766
28767   arg1 = (Dali::RenderTask *)jarg1;
28768   argp2 = (Dali::Viewport *)jarg2;
28769   if (!argp2) {
28770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
28771     return ;
28772   }
28773   arg2 = *argp2;
28774   {
28775     try {
28776       (arg1)->SetViewport(arg2);
28777     } catch (std::out_of_range& e) {
28778       {
28779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28780       };
28781     } catch (std::exception& e) {
28782       {
28783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28784       };
28785     } catch (Dali::DaliException e) {
28786       {
28787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28788       };
28789     } catch (...) {
28790       {
28791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28792       };
28793     }
28794   }
28795
28796 }
28797
28798
28799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
28800   void * jresult ;
28801   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28802   Dali::Viewport result;
28803
28804   arg1 = (Dali::RenderTask *)jarg1;
28805   {
28806     try {
28807       result = ((Dali::RenderTask const *)arg1)->GetViewport();
28808     } catch (std::out_of_range& e) {
28809       {
28810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28811       };
28812     } catch (std::exception& e) {
28813       {
28814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28815       };
28816     } catch (Dali::DaliException e) {
28817       {
28818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28819       };
28820     } catch (...) {
28821       {
28822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28823       };
28824     }
28825   }
28826
28827   jresult = new Dali::Viewport((const Dali::Viewport &)result);
28828   return jresult;
28829 }
28830
28831
28832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
28833   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28834   Dali::Vector4 *arg2 = 0 ;
28835
28836   arg1 = (Dali::RenderTask *)jarg1;
28837   arg2 = (Dali::Vector4 *)jarg2;
28838   if (!arg2) {
28839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
28840     return ;
28841   }
28842   {
28843     try {
28844       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
28845     } catch (std::out_of_range& e) {
28846       {
28847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28848       };
28849     } catch (std::exception& e) {
28850       {
28851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28852       };
28853     } catch (Dali::DaliException e) {
28854       {
28855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28856       };
28857     } catch (...) {
28858       {
28859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28860       };
28861     }
28862   }
28863
28864 }
28865
28866
28867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
28868   void * jresult ;
28869   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28870   Dali::Vector4 result;
28871
28872   arg1 = (Dali::RenderTask *)jarg1;
28873   {
28874     try {
28875       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
28876     } catch (std::out_of_range& e) {
28877       {
28878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28879       };
28880     } catch (std::exception& e) {
28881       {
28882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28883       };
28884     } catch (Dali::DaliException e) {
28885       {
28886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28887       };
28888     } catch (...) {
28889       {
28890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28891       };
28892     }
28893   }
28894
28895   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
28896   return jresult;
28897 }
28898
28899
28900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
28901   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28902   bool arg2 ;
28903
28904   arg1 = (Dali::RenderTask *)jarg1;
28905   arg2 = jarg2 ? true : false;
28906   {
28907     try {
28908       (arg1)->SetClearEnabled(arg2);
28909     } catch (std::out_of_range& e) {
28910       {
28911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28912       };
28913     } catch (std::exception& e) {
28914       {
28915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28916       };
28917     } catch (Dali::DaliException e) {
28918       {
28919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28920       };
28921     } catch (...) {
28922       {
28923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28924       };
28925     }
28926   }
28927
28928 }
28929
28930
28931 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
28932   unsigned int jresult ;
28933   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28934   bool result;
28935
28936   arg1 = (Dali::RenderTask *)jarg1;
28937   {
28938     try {
28939       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
28940     } catch (std::out_of_range& e) {
28941       {
28942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28943       };
28944     } catch (std::exception& e) {
28945       {
28946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28947       };
28948     } catch (Dali::DaliException e) {
28949       {
28950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28951       };
28952     } catch (...) {
28953       {
28954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28955       };
28956     }
28957   }
28958
28959   jresult = result;
28960   return jresult;
28961 }
28962
28963
28964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
28965   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28966   bool arg2 ;
28967
28968   arg1 = (Dali::RenderTask *)jarg1;
28969   arg2 = jarg2 ? true : false;
28970   {
28971     try {
28972       (arg1)->SetCullMode(arg2);
28973     } catch (std::out_of_range& e) {
28974       {
28975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28976       };
28977     } catch (std::exception& e) {
28978       {
28979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28980       };
28981     } catch (Dali::DaliException e) {
28982       {
28983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28984       };
28985     } catch (...) {
28986       {
28987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28988       };
28989     }
28990   }
28991
28992 }
28993
28994
28995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
28996   unsigned int jresult ;
28997   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28998   bool result;
28999
29000   arg1 = (Dali::RenderTask *)jarg1;
29001   {
29002     try {
29003       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29004     } catch (std::out_of_range& e) {
29005       {
29006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29007       };
29008     } catch (std::exception& e) {
29009       {
29010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29011       };
29012     } catch (Dali::DaliException e) {
29013       {
29014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29015       };
29016     } catch (...) {
29017       {
29018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29019       };
29020     }
29021   }
29022
29023   jresult = result;
29024   return jresult;
29025 }
29026
29027
29028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29029   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29030   unsigned int arg2 ;
29031
29032   arg1 = (Dali::RenderTask *)jarg1;
29033   arg2 = (unsigned int)jarg2;
29034   {
29035     try {
29036       (arg1)->SetRefreshRate(arg2);
29037     } catch (std::out_of_range& e) {
29038       {
29039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29040       };
29041     } catch (std::exception& e) {
29042       {
29043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29044       };
29045     } catch (Dali::DaliException e) {
29046       {
29047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29048       };
29049     } catch (...) {
29050       {
29051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29052       };
29053     }
29054   }
29055
29056 }
29057
29058
29059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29060   unsigned int jresult ;
29061   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29062   unsigned int result;
29063
29064   arg1 = (Dali::RenderTask *)jarg1;
29065   {
29066     try {
29067       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29068     } catch (std::out_of_range& e) {
29069       {
29070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29071       };
29072     } catch (std::exception& e) {
29073       {
29074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29075       };
29076     } catch (Dali::DaliException e) {
29077       {
29078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29079       };
29080     } catch (...) {
29081       {
29082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29083       };
29084     }
29085   }
29086
29087   jresult = result;
29088   return jresult;
29089 }
29090
29091
29092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29093   unsigned int jresult ;
29094   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29095   Dali::Vector3 *arg2 = 0 ;
29096   float *arg3 = 0 ;
29097   float *arg4 = 0 ;
29098   bool result;
29099
29100   arg1 = (Dali::RenderTask *)jarg1;
29101   arg2 = (Dali::Vector3 *)jarg2;
29102   if (!arg2) {
29103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29104     return 0;
29105   }
29106   arg3 = (float *)jarg3;
29107   arg4 = (float *)jarg4;
29108   {
29109     try {
29110       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29111     } catch (std::out_of_range& e) {
29112       {
29113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29114       };
29115     } catch (std::exception& e) {
29116       {
29117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29118       };
29119     } catch (Dali::DaliException e) {
29120       {
29121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29122       };
29123     } catch (...) {
29124       {
29125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29126       };
29127     }
29128   }
29129
29130   jresult = result;
29131   return jresult;
29132 }
29133
29134
29135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29136   unsigned int jresult ;
29137   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29138   Dali::Actor arg2 ;
29139   float arg3 ;
29140   float arg4 ;
29141   float *arg5 = 0 ;
29142   float *arg6 = 0 ;
29143   Dali::Actor *argp2 ;
29144   bool result;
29145
29146   arg1 = (Dali::RenderTask *)jarg1;
29147   argp2 = (Dali::Actor *)jarg2;
29148   if (!argp2) {
29149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29150     return 0;
29151   }
29152   arg2 = *argp2;
29153   arg3 = (float)jarg3;
29154   arg4 = (float)jarg4;
29155   arg5 = (float *)jarg5;
29156   arg6 = (float *)jarg6;
29157   {
29158     try {
29159       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29160     } catch (std::out_of_range& e) {
29161       {
29162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29163       };
29164     } catch (std::exception& e) {
29165       {
29166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29167       };
29168     } catch (Dali::DaliException e) {
29169       {
29170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29171       };
29172     } catch (...) {
29173       {
29174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29175       };
29176     }
29177   }
29178
29179   jresult = result;
29180   return jresult;
29181 }
29182
29183
29184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29185   void * jresult ;
29186   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29187   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29188
29189   arg1 = (Dali::RenderTask *)jarg1;
29190   {
29191     try {
29192       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29193     } catch (std::out_of_range& e) {
29194       {
29195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29196       };
29197     } catch (std::exception& e) {
29198       {
29199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29200       };
29201     } catch (Dali::DaliException e) {
29202       {
29203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29204       };
29205     } catch (...) {
29206       {
29207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29208       };
29209     }
29210   }
29211
29212   jresult = (void *)result;
29213   return jresult;
29214 }
29215
29216
29217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29218   void * jresult ;
29219   int arg1 ;
29220   Dali::TouchPoint::State arg2 ;
29221   float arg3 ;
29222   float arg4 ;
29223   Dali::TouchPoint *result = 0 ;
29224
29225   arg1 = (int)jarg1;
29226   arg2 = (Dali::TouchPoint::State)jarg2;
29227   arg3 = (float)jarg3;
29228   arg4 = (float)jarg4;
29229   {
29230     try {
29231       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29232     } catch (std::out_of_range& e) {
29233       {
29234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29235       };
29236     } catch (std::exception& e) {
29237       {
29238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29239       };
29240     } catch (Dali::DaliException e) {
29241       {
29242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29243       };
29244     } catch (...) {
29245       {
29246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29247       };
29248     }
29249   }
29250
29251   jresult = (void *)result;
29252   return jresult;
29253 }
29254
29255
29256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29257   void * jresult ;
29258   int arg1 ;
29259   Dali::TouchPoint::State arg2 ;
29260   float arg3 ;
29261   float arg4 ;
29262   float arg5 ;
29263   float arg6 ;
29264   Dali::TouchPoint *result = 0 ;
29265
29266   arg1 = (int)jarg1;
29267   arg2 = (Dali::TouchPoint::State)jarg2;
29268   arg3 = (float)jarg3;
29269   arg4 = (float)jarg4;
29270   arg5 = (float)jarg5;
29271   arg6 = (float)jarg6;
29272   {
29273     try {
29274       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29275     } catch (std::out_of_range& e) {
29276       {
29277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29278       };
29279     } catch (std::exception& e) {
29280       {
29281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29282       };
29283     } catch (Dali::DaliException e) {
29284       {
29285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29286       };
29287     } catch (...) {
29288       {
29289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29290       };
29291     }
29292   }
29293
29294   jresult = (void *)result;
29295   return jresult;
29296 }
29297
29298
29299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29300   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29301
29302   arg1 = (Dali::TouchPoint *)jarg1;
29303   {
29304     try {
29305       delete arg1;
29306     } catch (std::out_of_range& e) {
29307       {
29308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29309       };
29310     } catch (std::exception& e) {
29311       {
29312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29313       };
29314     } catch (Dali::DaliException e) {
29315       {
29316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29317       };
29318     } catch (...) {
29319       {
29320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29321       };
29322     }
29323   }
29324
29325 }
29326
29327
29328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29329   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29330   int arg2 ;
29331
29332   arg1 = (Dali::TouchPoint *)jarg1;
29333   arg2 = (int)jarg2;
29334   if (arg1) (arg1)->deviceId = arg2;
29335 }
29336
29337
29338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29339   int jresult ;
29340   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29341   int result;
29342
29343   arg1 = (Dali::TouchPoint *)jarg1;
29344   result = (int) ((arg1)->deviceId);
29345   jresult = result;
29346   return jresult;
29347 }
29348
29349
29350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29351   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29352   Dali::TouchPoint::State arg2 ;
29353
29354   arg1 = (Dali::TouchPoint *)jarg1;
29355   arg2 = (Dali::TouchPoint::State)jarg2;
29356   if (arg1) (arg1)->state = arg2;
29357 }
29358
29359
29360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29361   int jresult ;
29362   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29363   Dali::TouchPoint::State result;
29364
29365   arg1 = (Dali::TouchPoint *)jarg1;
29366   result = (Dali::TouchPoint::State) ((arg1)->state);
29367   jresult = (int)result;
29368   return jresult;
29369 }
29370
29371
29372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29373   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29374   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29375
29376   arg1 = (Dali::TouchPoint *)jarg1;
29377   arg2 = (Dali::Actor *)jarg2;
29378   if (arg1) (arg1)->hitActor = *arg2;
29379 }
29380
29381
29382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29383   void * jresult ;
29384   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29385   Dali::Actor *result = 0 ;
29386
29387   arg1 = (Dali::TouchPoint *)jarg1;
29388   result = (Dali::Actor *)& ((arg1)->hitActor);
29389   jresult = (void *)result;
29390   return jresult;
29391 }
29392
29393
29394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29395   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29396   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29397
29398   arg1 = (Dali::TouchPoint *)jarg1;
29399   arg2 = (Dali::Vector2 *)jarg2;
29400   if (arg1) (arg1)->local = *arg2;
29401 }
29402
29403
29404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29405   void * jresult ;
29406   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29407   Dali::Vector2 *result = 0 ;
29408
29409   arg1 = (Dali::TouchPoint *)jarg1;
29410   result = (Dali::Vector2 *)& ((arg1)->local);
29411   jresult = (void *)result;
29412   return jresult;
29413 }
29414
29415
29416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29417   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29418   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29419
29420   arg1 = (Dali::TouchPoint *)jarg1;
29421   arg2 = (Dali::Vector2 *)jarg2;
29422   if (arg1) (arg1)->screen = *arg2;
29423 }
29424
29425
29426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29427   void * jresult ;
29428   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29429   Dali::Vector2 *result = 0 ;
29430
29431   arg1 = (Dali::TouchPoint *)jarg1;
29432   result = (Dali::Vector2 *)& ((arg1)->screen);
29433   jresult = (void *)result;
29434   return jresult;
29435 }
29436
29437
29438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29439   void * jresult ;
29440   Dali::TouchData *result = 0 ;
29441
29442   {
29443     try {
29444       result = (Dali::TouchData *)new Dali::TouchData();
29445     } catch (std::out_of_range& e) {
29446       {
29447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29448       };
29449     } catch (std::exception& e) {
29450       {
29451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29452       };
29453     } catch (Dali::DaliException e) {
29454       {
29455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29456       };
29457     } catch (...) {
29458       {
29459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29460       };
29461     }
29462   }
29463
29464   jresult = (void *)result;
29465   return jresult;
29466 }
29467
29468
29469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29470   void * jresult ;
29471   Dali::TouchData *arg1 = 0 ;
29472   Dali::TouchData *result = 0 ;
29473
29474   arg1 = (Dali::TouchData *)jarg1;
29475   if (!arg1) {
29476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29477     return 0;
29478   }
29479   {
29480     try {
29481       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29482     } catch (std::out_of_range& e) {
29483       {
29484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29485       };
29486     } catch (std::exception& e) {
29487       {
29488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29489       };
29490     } catch (Dali::DaliException e) {
29491       {
29492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29493       };
29494     } catch (...) {
29495       {
29496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29497       };
29498     }
29499   }
29500
29501   jresult = (void *)result;
29502   return jresult;
29503 }
29504
29505
29506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29507   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29508
29509   arg1 = (Dali::TouchData *)jarg1;
29510   {
29511     try {
29512       delete arg1;
29513     } catch (std::out_of_range& e) {
29514       {
29515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29516       };
29517     } catch (std::exception& e) {
29518       {
29519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29520       };
29521     } catch (Dali::DaliException e) {
29522       {
29523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29524       };
29525     } catch (...) {
29526       {
29527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29528       };
29529     }
29530   }
29531
29532 }
29533
29534
29535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29536   void * jresult ;
29537   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29538   Dali::TouchData *arg2 = 0 ;
29539   Dali::TouchData *result = 0 ;
29540
29541   arg1 = (Dali::TouchData *)jarg1;
29542   arg2 = (Dali::TouchData *)jarg2;
29543   if (!arg2) {
29544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29545     return 0;
29546   }
29547   {
29548     try {
29549       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29550     } catch (std::out_of_range& e) {
29551       {
29552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29553       };
29554     } catch (std::exception& e) {
29555       {
29556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29557       };
29558     } catch (Dali::DaliException e) {
29559       {
29560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29561       };
29562     } catch (...) {
29563       {
29564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29565       };
29566     }
29567   }
29568
29569   jresult = (void *)result;
29570   return jresult;
29571 }
29572
29573
29574 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29575   unsigned long jresult ;
29576   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29577   unsigned long result;
29578
29579   arg1 = (Dali::TouchData *)jarg1;
29580   {
29581     try {
29582       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29583     } catch (std::out_of_range& e) {
29584       {
29585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29586       };
29587     } catch (std::exception& e) {
29588       {
29589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29590       };
29591     } catch (Dali::DaliException e) {
29592       {
29593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29594       };
29595     } catch (...) {
29596       {
29597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29598       };
29599     }
29600   }
29601
29602   jresult = (unsigned long)result;
29603   return jresult;
29604 }
29605
29606
29607 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29608   unsigned long jresult ;
29609   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29610   std::size_t result;
29611
29612   arg1 = (Dali::TouchData *)jarg1;
29613   {
29614     try {
29615       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29616     } catch (std::out_of_range& e) {
29617       {
29618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29619       };
29620     } catch (std::exception& e) {
29621       {
29622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29623       };
29624     } catch (Dali::DaliException e) {
29625       {
29626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29627       };
29628     } catch (...) {
29629       {
29630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29631       };
29632     }
29633   }
29634
29635   jresult = (unsigned long)result;
29636   return jresult;
29637 }
29638
29639
29640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29641   int jresult ;
29642   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29643   std::size_t arg2 ;
29644   int32_t result;
29645
29646   arg1 = (Dali::TouchData *)jarg1;
29647   arg2 = (std::size_t)jarg2;
29648   {
29649     try {
29650       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29651     } catch (std::out_of_range& e) {
29652       {
29653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29654       };
29655     } catch (std::exception& e) {
29656       {
29657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29658       };
29659     } catch (Dali::DaliException e) {
29660       {
29661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29662       };
29663     } catch (...) {
29664       {
29665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29666       };
29667     }
29668   }
29669
29670   jresult = result;
29671   return jresult;
29672 }
29673
29674
29675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29676   int jresult ;
29677   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29678   std::size_t arg2 ;
29679   Dali::PointState::Type result;
29680
29681   arg1 = (Dali::TouchData *)jarg1;
29682   arg2 = (std::size_t)jarg2;
29683   {
29684     try {
29685       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29686     } catch (std::out_of_range& e) {
29687       {
29688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29689       };
29690     } catch (std::exception& e) {
29691       {
29692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29693       };
29694     } catch (Dali::DaliException e) {
29695       {
29696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29697       };
29698     } catch (...) {
29699       {
29700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29701       };
29702     }
29703   }
29704
29705   jresult = (int)result;
29706   return jresult;
29707 }
29708
29709
29710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29711   void * jresult ;
29712   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29713   std::size_t arg2 ;
29714   Dali::Actor result;
29715
29716   arg1 = (Dali::TouchData *)jarg1;
29717   arg2 = (std::size_t)jarg2;
29718   {
29719     try {
29720       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
29721     } catch (std::out_of_range& e) {
29722       {
29723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29724       };
29725     } catch (std::exception& e) {
29726       {
29727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29728       };
29729     } catch (Dali::DaliException e) {
29730       {
29731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29732       };
29733     } catch (...) {
29734       {
29735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29736       };
29737     }
29738   }
29739
29740   jresult = new Dali::Actor((const Dali::Actor &)result);
29741   return jresult;
29742 }
29743
29744
29745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
29746   void * jresult ;
29747   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29748   std::size_t arg2 ;
29749   Dali::Vector2 *result = 0 ;
29750
29751   arg1 = (Dali::TouchData *)jarg1;
29752   arg2 = (std::size_t)jarg2;
29753   {
29754     try {
29755       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
29756     } catch (std::out_of_range& e) {
29757       {
29758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29759       };
29760     } catch (std::exception& e) {
29761       {
29762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29763       };
29764     } catch (Dali::DaliException e) {
29765       {
29766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29767       };
29768     } catch (...) {
29769       {
29770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29771       };
29772     }
29773   }
29774
29775   jresult = (void *)result;
29776   return jresult;
29777 }
29778
29779
29780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
29781   void * jresult ;
29782   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29783   std::size_t arg2 ;
29784   Dali::Vector2 *result = 0 ;
29785
29786   arg1 = (Dali::TouchData *)jarg1;
29787   arg2 = (std::size_t)jarg2;
29788   {
29789     try {
29790       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
29791     } catch (std::out_of_range& e) {
29792       {
29793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29794       };
29795     } catch (std::exception& e) {
29796       {
29797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29798       };
29799     } catch (Dali::DaliException e) {
29800       {
29801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29802       };
29803     } catch (...) {
29804       {
29805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29806       };
29807     }
29808   }
29809
29810   jresult = (void *)result;
29811   return jresult;
29812 }
29813
29814
29815 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
29816   float jresult ;
29817   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29818   std::size_t arg2 ;
29819   float result;
29820
29821   arg1 = (Dali::TouchData *)jarg1;
29822   arg2 = (std::size_t)jarg2;
29823   {
29824     try {
29825       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
29826     } catch (std::out_of_range& e) {
29827       {
29828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29829       };
29830     } catch (std::exception& e) {
29831       {
29832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29833       };
29834     } catch (Dali::DaliException e) {
29835       {
29836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29837       };
29838     } catch (...) {
29839       {
29840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29841       };
29842     }
29843   }
29844
29845   jresult = result;
29846   return jresult;
29847 }
29848
29849
29850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
29851   void * jresult ;
29852   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29853   std::size_t arg2 ;
29854   Dali::Vector2 *result = 0 ;
29855
29856   arg1 = (Dali::TouchData *)jarg1;
29857   arg2 = (std::size_t)jarg2;
29858   {
29859     try {
29860       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
29861     } catch (std::out_of_range& e) {
29862       {
29863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29864       };
29865     } catch (std::exception& e) {
29866       {
29867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29868       };
29869     } catch (Dali::DaliException e) {
29870       {
29871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29872       };
29873     } catch (...) {
29874       {
29875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29876       };
29877     }
29878   }
29879
29880   jresult = (void *)result;
29881   return jresult;
29882 }
29883
29884
29885 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
29886   float jresult ;
29887   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29888   std::size_t arg2 ;
29889   float result;
29890
29891   arg1 = (Dali::TouchData *)jarg1;
29892   arg2 = (std::size_t)jarg2;
29893   {
29894     try {
29895       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
29896     } catch (std::out_of_range& e) {
29897       {
29898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29899       };
29900     } catch (std::exception& e) {
29901       {
29902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29903       };
29904     } catch (Dali::DaliException e) {
29905       {
29906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29907       };
29908     } catch (...) {
29909       {
29910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29911       };
29912     }
29913   }
29914
29915   jresult = result;
29916   return jresult;
29917 }
29918
29919
29920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
29921   void * jresult ;
29922   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29923   std::size_t arg2 ;
29924   Dali::Degree result;
29925
29926   arg1 = (Dali::TouchData *)jarg1;
29927   arg2 = (std::size_t)jarg2;
29928   {
29929     try {
29930       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
29931     } catch (std::out_of_range& e) {
29932       {
29933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29934       };
29935     } catch (std::exception& e) {
29936       {
29937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29938       };
29939     } catch (Dali::DaliException e) {
29940       {
29941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29942       };
29943     } catch (...) {
29944       {
29945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29946       };
29947     }
29948   }
29949
29950   jresult = new Dali::Degree((const Dali::Degree &)result);
29951   return jresult;
29952 }
29953
29954
29955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
29956   int jresult ;
29957   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29958   std::size_t arg2 ;
29959   Dali::MouseButton::Type result;
29960
29961   arg1 = (Dali::TouchData *)jarg1;
29962   arg2 = (std::size_t)jarg2;
29963   {
29964     try {
29965       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
29966     } catch (std::out_of_range& e) {
29967       {
29968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29969       };
29970     } catch (std::exception& e) {
29971       {
29972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29973       };
29974     } catch (Dali::DaliException e) {
29975       {
29976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29977       };
29978     } catch (...) {
29979       {
29980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29981       };
29982     }
29983   }
29984
29985   jresult = static_cast< int >(result);
29986   return jresult;
29987 }
29988
29989
29990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
29991   void * jresult ;
29992   Dali::GestureDetector *result = 0 ;
29993
29994   {
29995     try {
29996       result = (Dali::GestureDetector *)new Dali::GestureDetector();
29997     } catch (std::out_of_range& e) {
29998       {
29999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30000       };
30001     } catch (std::exception& e) {
30002       {
30003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30004       };
30005     } catch (Dali::DaliException e) {
30006       {
30007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30008       };
30009     } catch (...) {
30010       {
30011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30012       };
30013     }
30014   }
30015
30016   jresult = (void *)result;
30017   return jresult;
30018 }
30019
30020
30021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30022   void * jresult ;
30023   Dali::BaseHandle arg1 ;
30024   Dali::BaseHandle *argp1 ;
30025   Dali::GestureDetector result;
30026
30027   argp1 = (Dali::BaseHandle *)jarg1;
30028   if (!argp1) {
30029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30030     return 0;
30031   }
30032   arg1 = *argp1;
30033   {
30034     try {
30035       result = Dali::GestureDetector::DownCast(arg1);
30036     } catch (std::out_of_range& e) {
30037       {
30038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30039       };
30040     } catch (std::exception& e) {
30041       {
30042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30043       };
30044     } catch (Dali::DaliException e) {
30045       {
30046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30047       };
30048     } catch (...) {
30049       {
30050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30051       };
30052     }
30053   }
30054
30055   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30056   return jresult;
30057 }
30058
30059
30060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30061   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30062
30063   arg1 = (Dali::GestureDetector *)jarg1;
30064   {
30065     try {
30066       delete arg1;
30067     } catch (std::out_of_range& e) {
30068       {
30069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30070       };
30071     } catch (std::exception& e) {
30072       {
30073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30074       };
30075     } catch (Dali::DaliException e) {
30076       {
30077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30078       };
30079     } catch (...) {
30080       {
30081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30082       };
30083     }
30084   }
30085
30086 }
30087
30088
30089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30090   void * jresult ;
30091   Dali::GestureDetector *arg1 = 0 ;
30092   Dali::GestureDetector *result = 0 ;
30093
30094   arg1 = (Dali::GestureDetector *)jarg1;
30095   if (!arg1) {
30096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30097     return 0;
30098   }
30099   {
30100     try {
30101       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30102     } catch (std::out_of_range& e) {
30103       {
30104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30105       };
30106     } catch (std::exception& e) {
30107       {
30108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30109       };
30110     } catch (Dali::DaliException e) {
30111       {
30112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30113       };
30114     } catch (...) {
30115       {
30116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30117       };
30118     }
30119   }
30120
30121   jresult = (void *)result;
30122   return jresult;
30123 }
30124
30125
30126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30127   void * jresult ;
30128   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30129   Dali::GestureDetector *arg2 = 0 ;
30130   Dali::GestureDetector *result = 0 ;
30131
30132   arg1 = (Dali::GestureDetector *)jarg1;
30133   arg2 = (Dali::GestureDetector *)jarg2;
30134   if (!arg2) {
30135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30136     return 0;
30137   }
30138   {
30139     try {
30140       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30141     } catch (std::out_of_range& e) {
30142       {
30143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30144       };
30145     } catch (std::exception& e) {
30146       {
30147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30148       };
30149     } catch (Dali::DaliException e) {
30150       {
30151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30152       };
30153     } catch (...) {
30154       {
30155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30156       };
30157     }
30158   }
30159
30160   jresult = (void *)result;
30161   return jresult;
30162 }
30163
30164
30165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30166   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30167   Dali::Actor arg2 ;
30168   Dali::Actor *argp2 ;
30169
30170   arg1 = (Dali::GestureDetector *)jarg1;
30171   argp2 = (Dali::Actor *)jarg2;
30172   if (!argp2) {
30173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30174     return ;
30175   }
30176   arg2 = *argp2;
30177   {
30178     try {
30179       (arg1)->Attach(arg2);
30180     } catch (std::out_of_range& e) {
30181       {
30182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30183       };
30184     } catch (std::exception& e) {
30185       {
30186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30187       };
30188     } catch (Dali::DaliException e) {
30189       {
30190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30191       };
30192     } catch (...) {
30193       {
30194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30195       };
30196     }
30197   }
30198
30199 }
30200
30201
30202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30203   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30204   Dali::Actor arg2 ;
30205   Dali::Actor *argp2 ;
30206
30207   arg1 = (Dali::GestureDetector *)jarg1;
30208   argp2 = (Dali::Actor *)jarg2;
30209   if (!argp2) {
30210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30211     return ;
30212   }
30213   arg2 = *argp2;
30214   {
30215     try {
30216       (arg1)->Detach(arg2);
30217     } catch (std::out_of_range& e) {
30218       {
30219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30220       };
30221     } catch (std::exception& e) {
30222       {
30223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30224       };
30225     } catch (Dali::DaliException e) {
30226       {
30227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30228       };
30229     } catch (...) {
30230       {
30231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30232       };
30233     }
30234   }
30235
30236 }
30237
30238
30239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30240   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30241
30242   arg1 = (Dali::GestureDetector *)jarg1;
30243   {
30244     try {
30245       (arg1)->DetachAll();
30246     } catch (std::out_of_range& e) {
30247       {
30248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30249       };
30250     } catch (std::exception& e) {
30251       {
30252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30253       };
30254     } catch (Dali::DaliException e) {
30255       {
30256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30257       };
30258     } catch (...) {
30259       {
30260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30261       };
30262     }
30263   }
30264
30265 }
30266
30267
30268 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30269   unsigned long jresult ;
30270   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30271   size_t result;
30272
30273   arg1 = (Dali::GestureDetector *)jarg1;
30274   {
30275     try {
30276       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30277     } catch (std::out_of_range& e) {
30278       {
30279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30280       };
30281     } catch (std::exception& e) {
30282       {
30283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30284       };
30285     } catch (Dali::DaliException e) {
30286       {
30287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30288       };
30289     } catch (...) {
30290       {
30291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30292       };
30293     }
30294   }
30295
30296   jresult = (unsigned long)result;
30297   return jresult;
30298 }
30299
30300
30301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30302   void * jresult ;
30303   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30304   size_t arg2 ;
30305   Dali::Actor result;
30306
30307   arg1 = (Dali::GestureDetector *)jarg1;
30308   arg2 = (size_t)jarg2;
30309   {
30310     try {
30311       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30312     } catch (std::out_of_range& e) {
30313       {
30314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30315       };
30316     } catch (std::exception& e) {
30317       {
30318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30319       };
30320     } catch (Dali::DaliException e) {
30321       {
30322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30323       };
30324     } catch (...) {
30325       {
30326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30327       };
30328     }
30329   }
30330
30331   jresult = new Dali::Actor((const Dali::Actor &)result);
30332   return jresult;
30333 }
30334
30335
30336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30337   void * jresult ;
30338   Dali::Gesture *arg1 = 0 ;
30339   Dali::Gesture *result = 0 ;
30340
30341   arg1 = (Dali::Gesture *)jarg1;
30342   if (!arg1) {
30343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30344     return 0;
30345   }
30346   {
30347     try {
30348       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30349     } catch (std::out_of_range& e) {
30350       {
30351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30352       };
30353     } catch (std::exception& e) {
30354       {
30355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30356       };
30357     } catch (Dali::DaliException e) {
30358       {
30359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30360       };
30361     } catch (...) {
30362       {
30363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30364       };
30365     }
30366   }
30367
30368   jresult = (void *)result;
30369   return jresult;
30370 }
30371
30372
30373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30374   void * jresult ;
30375   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30376   Dali::Gesture *arg2 = 0 ;
30377   Dali::Gesture *result = 0 ;
30378
30379   arg1 = (Dali::Gesture *)jarg1;
30380   arg2 = (Dali::Gesture *)jarg2;
30381   if (!arg2) {
30382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30383     return 0;
30384   }
30385   {
30386     try {
30387       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30388     } catch (std::out_of_range& e) {
30389       {
30390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30391       };
30392     } catch (std::exception& e) {
30393       {
30394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30395       };
30396     } catch (Dali::DaliException e) {
30397       {
30398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30399       };
30400     } catch (...) {
30401       {
30402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30403       };
30404     }
30405   }
30406
30407   jresult = (void *)result;
30408   return jresult;
30409 }
30410
30411
30412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30413   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30414
30415   arg1 = (Dali::Gesture *)jarg1;
30416   {
30417     try {
30418       delete arg1;
30419     } catch (std::out_of_range& e) {
30420       {
30421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30422       };
30423     } catch (std::exception& e) {
30424       {
30425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30426       };
30427     } catch (Dali::DaliException e) {
30428       {
30429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30430       };
30431     } catch (...) {
30432       {
30433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30434       };
30435     }
30436   }
30437
30438 }
30439
30440
30441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30442   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30443   Dali::Gesture::Type arg2 ;
30444
30445   arg1 = (Dali::Gesture *)jarg1;
30446   arg2 = (Dali::Gesture::Type)jarg2;
30447   if (arg1) (arg1)->type = arg2;
30448 }
30449
30450
30451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30452   int jresult ;
30453   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30454   Dali::Gesture::Type result;
30455
30456   arg1 = (Dali::Gesture *)jarg1;
30457   result = (Dali::Gesture::Type) ((arg1)->type);
30458   jresult = (int)result;
30459   return jresult;
30460 }
30461
30462
30463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30464   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30465   Dali::Gesture::State arg2 ;
30466
30467   arg1 = (Dali::Gesture *)jarg1;
30468   arg2 = (Dali::Gesture::State)jarg2;
30469   if (arg1) (arg1)->state = arg2;
30470 }
30471
30472
30473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30474   int jresult ;
30475   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30476   Dali::Gesture::State result;
30477
30478   arg1 = (Dali::Gesture *)jarg1;
30479   result = (Dali::Gesture::State) ((arg1)->state);
30480   jresult = (int)result;
30481   return jresult;
30482 }
30483
30484
30485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30486   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30487   unsigned int arg2 ;
30488
30489   arg1 = (Dali::Gesture *)jarg1;
30490   arg2 = (unsigned int)jarg2;
30491   if (arg1) (arg1)->time = arg2;
30492 }
30493
30494
30495 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30496   unsigned int jresult ;
30497   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30498   unsigned int result;
30499
30500   arg1 = (Dali::Gesture *)jarg1;
30501   result = (unsigned int) ((arg1)->time);
30502   jresult = result;
30503   return jresult;
30504 }
30505
30506
30507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30508   void * jresult ;
30509   Dali::HoverEvent *result = 0 ;
30510
30511   {
30512     try {
30513       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30514     } catch (std::out_of_range& e) {
30515       {
30516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30517       };
30518     } catch (std::exception& e) {
30519       {
30520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30521       };
30522     } catch (Dali::DaliException e) {
30523       {
30524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30525       };
30526     } catch (...) {
30527       {
30528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30529       };
30530     }
30531   }
30532
30533   jresult = (void *)result;
30534   return jresult;
30535 }
30536
30537
30538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30539   void * jresult ;
30540   unsigned long arg1 ;
30541   Dali::HoverEvent *result = 0 ;
30542
30543   arg1 = (unsigned long)jarg1;
30544   {
30545     try {
30546       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30547     } catch (std::out_of_range& e) {
30548       {
30549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30550       };
30551     } catch (std::exception& e) {
30552       {
30553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30554       };
30555     } catch (Dali::DaliException e) {
30556       {
30557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30558       };
30559     } catch (...) {
30560       {
30561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30562       };
30563     }
30564   }
30565
30566   jresult = (void *)result;
30567   return jresult;
30568 }
30569
30570
30571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30572   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30573
30574   arg1 = (Dali::HoverEvent *)jarg1;
30575   {
30576     try {
30577       delete arg1;
30578     } catch (std::out_of_range& e) {
30579       {
30580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30581       };
30582     } catch (std::exception& e) {
30583       {
30584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30585       };
30586     } catch (Dali::DaliException e) {
30587       {
30588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30589       };
30590     } catch (...) {
30591       {
30592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30593       };
30594     }
30595   }
30596
30597 }
30598
30599
30600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30601   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30602   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30603
30604   arg1 = (Dali::HoverEvent *)jarg1;
30605   arg2 = (Dali::TouchPointContainer *)jarg2;
30606   if (arg1) (arg1)->points = *arg2;
30607 }
30608
30609
30610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30611   void * jresult ;
30612   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30613   Dali::TouchPointContainer *result = 0 ;
30614
30615   arg1 = (Dali::HoverEvent *)jarg1;
30616   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30617   jresult = (void *)result;
30618   return jresult;
30619 }
30620
30621
30622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30623   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30624   unsigned long arg2 ;
30625
30626   arg1 = (Dali::HoverEvent *)jarg1;
30627   arg2 = (unsigned long)jarg2;
30628   if (arg1) (arg1)->time = arg2;
30629 }
30630
30631
30632 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30633   unsigned long jresult ;
30634   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30635   unsigned long result;
30636
30637   arg1 = (Dali::HoverEvent *)jarg1;
30638   result = (unsigned long) ((arg1)->time);
30639   jresult = (unsigned long)result;
30640   return jresult;
30641 }
30642
30643
30644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30645   unsigned int jresult ;
30646   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30647   unsigned int result;
30648
30649   arg1 = (Dali::HoverEvent *)jarg1;
30650   {
30651     try {
30652       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30653     } catch (std::out_of_range& e) {
30654       {
30655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30656       };
30657     } catch (std::exception& e) {
30658       {
30659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30660       };
30661     } catch (Dali::DaliException e) {
30662       {
30663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30664       };
30665     } catch (...) {
30666       {
30667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30668       };
30669     }
30670   }
30671
30672   jresult = result;
30673   return jresult;
30674 }
30675
30676
30677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30678   void * jresult ;
30679   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30680   unsigned int arg2 ;
30681   Dali::TouchPoint *result = 0 ;
30682
30683   arg1 = (Dali::HoverEvent *)jarg1;
30684   arg2 = (unsigned int)jarg2;
30685   {
30686     try {
30687       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30688     } catch (std::out_of_range& e) {
30689       {
30690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30691       };
30692     } catch (std::exception& e) {
30693       {
30694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30695       };
30696     } catch (Dali::DaliException e) {
30697       {
30698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30699       };
30700     } catch (...) {
30701       {
30702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30703       };
30704     }
30705   }
30706
30707   jresult = (void *)result;
30708   return jresult;
30709 }
30710
30711
30712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30713   void * jresult ;
30714   Dali::KeyEvent *result = 0 ;
30715
30716   {
30717     try {
30718       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30719     } catch (std::out_of_range& e) {
30720       {
30721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30722       };
30723     } catch (std::exception& e) {
30724       {
30725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30726       };
30727     } catch (Dali::DaliException e) {
30728       {
30729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30730       };
30731     } catch (...) {
30732       {
30733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30734       };
30735     }
30736   }
30737
30738   jresult = (void *)result;
30739   return jresult;
30740 }
30741
30742
30743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
30744   void * jresult ;
30745   std::string *arg1 = 0 ;
30746   std::string *arg2 = 0 ;
30747   int arg3 ;
30748   int arg4 ;
30749   unsigned long arg5 ;
30750   Dali::KeyEvent::State *arg6 = 0 ;
30751   Dali::KeyEvent::State temp6 ;
30752   Dali::KeyEvent *result = 0 ;
30753
30754   if (!jarg1) {
30755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30756     return 0;
30757   }
30758   std::string arg1_str(jarg1);
30759   arg1 = &arg1_str;
30760   if (!jarg2) {
30761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30762     return 0;
30763   }
30764   std::string arg2_str(jarg2);
30765   arg2 = &arg2_str;
30766   arg3 = (int)jarg3;
30767   arg4 = (int)jarg4;
30768   arg5 = (unsigned long)jarg5;
30769   temp6 = (Dali::KeyEvent::State)jarg6;
30770   arg6 = &temp6;
30771   {
30772     try {
30773       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
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 = (void *)result;
30794
30795   //argout typemap for const std::string&
30796
30797
30798   //argout typemap for const std::string&
30799
30800   return jresult;
30801 }
30802
30803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
30804   void * jresult ;
30805   Dali::KeyEvent *arg1 = 0 ;
30806   Dali::KeyEvent *result = 0 ;
30807
30808   arg1 = (Dali::KeyEvent *)jarg1;
30809   if (!arg1) {
30810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30811     return 0;
30812   }
30813   {
30814     try {
30815       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
30816     } catch (std::out_of_range& e) {
30817       {
30818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30819       };
30820     } catch (std::exception& e) {
30821       {
30822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30823       };
30824     } catch (Dali::DaliException e) {
30825       {
30826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30827       };
30828     } catch (...) {
30829       {
30830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30831       };
30832     }
30833   }
30834
30835   jresult = (void *)result;
30836   return jresult;
30837 }
30838
30839
30840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
30841   void * jresult ;
30842   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30843   Dali::KeyEvent *arg2 = 0 ;
30844   Dali::KeyEvent *result = 0 ;
30845
30846   arg1 = (Dali::KeyEvent *)jarg1;
30847   arg2 = (Dali::KeyEvent *)jarg2;
30848   if (!arg2) {
30849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30850     return 0;
30851   }
30852   {
30853     try {
30854       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
30855     } catch (std::out_of_range& e) {
30856       {
30857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30858       };
30859     } catch (std::exception& e) {
30860       {
30861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30862       };
30863     } catch (Dali::DaliException e) {
30864       {
30865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30866       };
30867     } catch (...) {
30868       {
30869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30870       };
30871     }
30872   }
30873
30874   jresult = (void *)result;
30875   return jresult;
30876 }
30877
30878
30879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
30880   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30881
30882   arg1 = (Dali::KeyEvent *)jarg1;
30883   {
30884     try {
30885       delete arg1;
30886     } catch (std::out_of_range& e) {
30887       {
30888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30889       };
30890     } catch (std::exception& e) {
30891       {
30892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30893       };
30894     } catch (Dali::DaliException e) {
30895       {
30896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30897       };
30898     } catch (...) {
30899       {
30900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30901       };
30902     }
30903   }
30904
30905 }
30906
30907
30908 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
30909   unsigned int jresult ;
30910   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30911   bool result;
30912
30913   arg1 = (Dali::KeyEvent *)jarg1;
30914   {
30915     try {
30916       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
30917     } catch (std::out_of_range& e) {
30918       {
30919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30920       };
30921     } catch (std::exception& e) {
30922       {
30923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30924       };
30925     } catch (Dali::DaliException e) {
30926       {
30927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30928       };
30929     } catch (...) {
30930       {
30931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30932       };
30933     }
30934   }
30935
30936   jresult = result;
30937   return jresult;
30938 }
30939
30940
30941 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
30942   unsigned int jresult ;
30943   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30944   bool result;
30945
30946   arg1 = (Dali::KeyEvent *)jarg1;
30947   {
30948     try {
30949       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
30950     } catch (std::out_of_range& e) {
30951       {
30952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30953       };
30954     } catch (std::exception& e) {
30955       {
30956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30957       };
30958     } catch (Dali::DaliException e) {
30959       {
30960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30961       };
30962     } catch (...) {
30963       {
30964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30965       };
30966     }
30967   }
30968
30969   jresult = result;
30970   return jresult;
30971 }
30972
30973
30974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
30975   unsigned int jresult ;
30976   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30977   bool result;
30978
30979   arg1 = (Dali::KeyEvent *)jarg1;
30980   {
30981     try {
30982       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
30983     } catch (std::out_of_range& e) {
30984       {
30985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30986       };
30987     } catch (std::exception& e) {
30988       {
30989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30990       };
30991     } catch (Dali::DaliException e) {
30992       {
30993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30994       };
30995     } catch (...) {
30996       {
30997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30998       };
30999     }
31000   }
31001
31002   jresult = result;
31003   return jresult;
31004 }
31005
31006
31007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31008   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31009   std::string *arg2 = 0 ;
31010
31011   arg1 = (Dali::KeyEvent *)jarg1;
31012   if (!jarg2) {
31013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31014     return ;
31015   }
31016   std::string arg2_str(jarg2);
31017   arg2 = &arg2_str;
31018   if (arg1) (arg1)->keyPressedName = *arg2;
31019
31020   //argout typemap for const std::string&
31021
31022 }
31023
31024
31025 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31026   char * jresult ;
31027
31028   if( jarg1 == NULL )
31029   {
31030     jresult = SWIG_csharp_string_callback( "" );
31031   }
31032   else
31033   {
31034     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31035     std::string *result = 0;
31036
31037     arg1 = ( Dali::KeyEvent * )jarg1;
31038     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31039     jresult = SWIG_csharp_string_callback( result->c_str() );
31040   }
31041
31042   return jresult;
31043 }
31044
31045
31046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31047   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31048   std::string *arg2 = 0 ;
31049
31050   arg1 = (Dali::KeyEvent *)jarg1;
31051   if (!jarg2) {
31052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31053     return ;
31054   }
31055   std::string arg2_str(jarg2);
31056   arg2 = &arg2_str;
31057   if (arg1) (arg1)->keyPressed = *arg2;
31058
31059   //argout typemap for const std::string&
31060
31061 }
31062
31063
31064 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31065   char * jresult ;
31066   if( NULL == jarg1 )
31067   {
31068     jresult = SWIG_csharp_string_callback( "" );
31069   }
31070   else
31071   {
31072     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31073     std::string *result = 0;
31074
31075     arg1 = ( Dali::KeyEvent * )jarg1;
31076     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31077     jresult = SWIG_csharp_string_callback( result->c_str() );
31078   }
31079   return jresult;
31080 }
31081
31082
31083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31084   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31085   int arg2 ;
31086
31087   arg1 = (Dali::KeyEvent *)jarg1;
31088   arg2 = (int)jarg2;
31089   if (arg1) (arg1)->keyCode = arg2;
31090 }
31091
31092
31093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31094   int jresult ;
31095   if( NULL == jarg1 )
31096   {
31097     jresult = -1;
31098   }
31099   else
31100   {
31101     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31102     int result;
31103
31104     arg1 = ( Dali::KeyEvent * )jarg1;
31105     result = (int)( ( arg1 )->keyCode );
31106     jresult = result;
31107   }
31108   return jresult;
31109 }
31110
31111
31112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31113   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31114   int arg2 ;
31115
31116   arg1 = (Dali::KeyEvent *)jarg1;
31117   arg2 = (int)jarg2;
31118   if (arg1) (arg1)->keyModifier = arg2;
31119 }
31120
31121
31122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31123   int jresult ;
31124   if( jarg1 == NULL )
31125   {
31126     jresult = -1;
31127   }
31128   else
31129   {
31130     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31131     int result;
31132
31133     arg1 = ( Dali::KeyEvent * )jarg1;
31134     result = (int)( ( arg1 )->keyModifier );
31135     jresult = result;
31136   }
31137   return jresult;
31138 }
31139
31140
31141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31142   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31143   unsigned long arg2 ;
31144
31145   arg1 = (Dali::KeyEvent *)jarg1;
31146   arg2 = (unsigned long)jarg2;
31147   if (arg1) (arg1)->time = arg2;
31148 }
31149
31150
31151 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31152   unsigned long jresult ;
31153   if( jarg1 == NULL )
31154   {
31155     jresult = 0;
31156   }
31157   else
31158   {
31159     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31160     unsigned long result;
31161
31162     arg1 = ( Dali::KeyEvent * )jarg1;
31163     result = (unsigned long)( ( arg1 )->time );
31164     jresult = (unsigned long)result;
31165   }
31166   return jresult;
31167 }
31168
31169
31170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31171   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31172   Dali::KeyEvent::State arg2 ;
31173
31174   arg1 = (Dali::KeyEvent *)jarg1;
31175   arg2 = (Dali::KeyEvent::State)jarg2;
31176   if (arg1) (arg1)->state = arg2;
31177 }
31178
31179
31180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31181   int jresult ;
31182   if( jarg1 == NULL )
31183   {
31184     jresult = -1;
31185   }
31186   else
31187   {
31188     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31189     Dali::KeyEvent::State result;
31190
31191     arg1 = ( Dali::KeyEvent * )jarg1;
31192     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31193     jresult = (int)result;
31194   }
31195   return jresult;
31196 }
31197
31198 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31199   char * jresult ;
31200   std::string result;
31201   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0;
31202
31203   arg1 = (Dali::KeyEvent *)jarg1;
31204   if (!arg1) {
31205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelKeyEvent const & type is null", 0);
31206     return 0;
31207   }
31208   {
31209     try {
31210       result = Dali::DevelKeyEvent::GetLogicalKey(*arg1);
31211     } catch (std::out_of_range& e) {
31212       {
31213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31214       };
31215     } catch (std::exception& e) {
31216       {
31217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31218       };
31219     } catch (Dali::DaliException e) {
31220       {
31221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31222       };
31223     } catch (...) {
31224       {
31225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31226       };
31227     }
31228
31229   }
31230
31231   jresult = SWIG_csharp_string_callback( (&result)->c_str() );
31232   return jresult;
31233 }
31234
31235
31236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31237   void * jresult ;
31238   Dali::LongPressGestureDetector *result = 0 ;
31239
31240   {
31241     try {
31242       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31243     } catch (std::out_of_range& e) {
31244       {
31245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31246       };
31247     } catch (std::exception& e) {
31248       {
31249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31250       };
31251     } catch (Dali::DaliException e) {
31252       {
31253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31254       };
31255     } catch (...) {
31256       {
31257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31258       };
31259     }
31260   }
31261
31262   jresult = (void *)result;
31263   return jresult;
31264 }
31265
31266
31267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31268   void * jresult ;
31269   Dali::LongPressGestureDetector result;
31270
31271   {
31272     try {
31273       result = Dali::LongPressGestureDetector::New();
31274     } catch (std::out_of_range& e) {
31275       {
31276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31277       };
31278     } catch (std::exception& e) {
31279       {
31280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31281       };
31282     } catch (Dali::DaliException e) {
31283       {
31284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31285       };
31286     } catch (...) {
31287       {
31288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31289       };
31290     }
31291   }
31292
31293   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31294   return jresult;
31295 }
31296
31297
31298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31299   void * jresult ;
31300   unsigned int arg1 ;
31301   Dali::LongPressGestureDetector result;
31302
31303   arg1 = (unsigned int)jarg1;
31304   {
31305     try {
31306       result = Dali::LongPressGestureDetector::New(arg1);
31307     } catch (std::out_of_range& e) {
31308       {
31309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31310       };
31311     } catch (std::exception& e) {
31312       {
31313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31314       };
31315     } catch (Dali::DaliException e) {
31316       {
31317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31318       };
31319     } catch (...) {
31320       {
31321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31322       };
31323     }
31324   }
31325
31326   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31327   return jresult;
31328 }
31329
31330
31331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31332   void * jresult ;
31333   unsigned int arg1 ;
31334   unsigned int arg2 ;
31335   Dali::LongPressGestureDetector result;
31336
31337   arg1 = (unsigned int)jarg1;
31338   arg2 = (unsigned int)jarg2;
31339   {
31340     try {
31341       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31342     } catch (std::out_of_range& e) {
31343       {
31344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31345       };
31346     } catch (std::exception& e) {
31347       {
31348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31349       };
31350     } catch (Dali::DaliException e) {
31351       {
31352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31353       };
31354     } catch (...) {
31355       {
31356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31357       };
31358     }
31359   }
31360
31361   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31362   return jresult;
31363 }
31364
31365
31366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31367   void * jresult ;
31368   Dali::BaseHandle arg1 ;
31369   Dali::BaseHandle *argp1 ;
31370   Dali::LongPressGestureDetector result;
31371
31372   argp1 = (Dali::BaseHandle *)jarg1;
31373   if (!argp1) {
31374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31375     return 0;
31376   }
31377   arg1 = *argp1;
31378   {
31379     try {
31380       result = Dali::LongPressGestureDetector::DownCast(arg1);
31381     } catch (std::out_of_range& e) {
31382       {
31383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31384       };
31385     } catch (std::exception& e) {
31386       {
31387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31388       };
31389     } catch (Dali::DaliException e) {
31390       {
31391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31392       };
31393     } catch (...) {
31394       {
31395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31396       };
31397     }
31398   }
31399
31400   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31401   return jresult;
31402 }
31403
31404
31405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31406   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31407
31408   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31409   {
31410     try {
31411       delete arg1;
31412     } catch (std::out_of_range& e) {
31413       {
31414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31415       };
31416     } catch (std::exception& e) {
31417       {
31418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31419       };
31420     } catch (Dali::DaliException e) {
31421       {
31422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31423       };
31424     } catch (...) {
31425       {
31426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31427       };
31428     }
31429   }
31430
31431 }
31432
31433
31434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31435   void * jresult ;
31436   Dali::LongPressGestureDetector *arg1 = 0 ;
31437   Dali::LongPressGestureDetector *result = 0 ;
31438
31439   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31440   if (!arg1) {
31441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31442     return 0;
31443   }
31444   {
31445     try {
31446       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31447     } catch (std::out_of_range& e) {
31448       {
31449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31450       };
31451     } catch (std::exception& e) {
31452       {
31453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31454       };
31455     } catch (Dali::DaliException e) {
31456       {
31457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31458       };
31459     } catch (...) {
31460       {
31461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31462       };
31463     }
31464   }
31465
31466   jresult = (void *)result;
31467   return jresult;
31468 }
31469
31470
31471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31472   void * jresult ;
31473   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31474   Dali::LongPressGestureDetector *arg2 = 0 ;
31475   Dali::LongPressGestureDetector *result = 0 ;
31476
31477   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31478   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31479   if (!arg2) {
31480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31481     return 0;
31482   }
31483   {
31484     try {
31485       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31486     } catch (std::out_of_range& e) {
31487       {
31488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31489       };
31490     } catch (std::exception& e) {
31491       {
31492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31493       };
31494     } catch (Dali::DaliException e) {
31495       {
31496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31497       };
31498     } catch (...) {
31499       {
31500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31501       };
31502     }
31503   }
31504
31505   jresult = (void *)result;
31506   return jresult;
31507 }
31508
31509
31510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31511   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31512   unsigned int arg2 ;
31513
31514   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31515   arg2 = (unsigned int)jarg2;
31516   {
31517     try {
31518       (arg1)->SetTouchesRequired(arg2);
31519     } catch (std::out_of_range& e) {
31520       {
31521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31522       };
31523     } catch (std::exception& e) {
31524       {
31525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31526       };
31527     } catch (Dali::DaliException e) {
31528       {
31529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31530       };
31531     } catch (...) {
31532       {
31533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31534       };
31535     }
31536   }
31537
31538 }
31539
31540
31541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31542   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31543   unsigned int arg2 ;
31544   unsigned int arg3 ;
31545
31546   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31547   arg2 = (unsigned int)jarg2;
31548   arg3 = (unsigned int)jarg3;
31549   {
31550     try {
31551       (arg1)->SetTouchesRequired(arg2,arg3);
31552     } catch (std::out_of_range& e) {
31553       {
31554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31555       };
31556     } catch (std::exception& e) {
31557       {
31558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31559       };
31560     } catch (Dali::DaliException e) {
31561       {
31562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31563       };
31564     } catch (...) {
31565       {
31566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31567       };
31568     }
31569   }
31570
31571 }
31572
31573
31574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31575   unsigned int jresult ;
31576   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31577   unsigned int result;
31578
31579   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31580   {
31581     try {
31582       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31583     } catch (std::out_of_range& e) {
31584       {
31585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31586       };
31587     } catch (std::exception& e) {
31588       {
31589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31590       };
31591     } catch (Dali::DaliException e) {
31592       {
31593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31594       };
31595     } catch (...) {
31596       {
31597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31598       };
31599     }
31600   }
31601
31602   jresult = result;
31603   return jresult;
31604 }
31605
31606
31607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31608   unsigned int jresult ;
31609   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31610   unsigned int result;
31611
31612   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31613   {
31614     try {
31615       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31616     } catch (std::out_of_range& e) {
31617       {
31618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31619       };
31620     } catch (std::exception& e) {
31621       {
31622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31623       };
31624     } catch (Dali::DaliException e) {
31625       {
31626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31627       };
31628     } catch (...) {
31629       {
31630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31631       };
31632     }
31633   }
31634
31635   jresult = result;
31636   return jresult;
31637 }
31638
31639
31640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31641   void * jresult ;
31642   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31643   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31644
31645   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31646   {
31647     try {
31648       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31649     } catch (std::out_of_range& e) {
31650       {
31651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31652       };
31653     } catch (std::exception& e) {
31654       {
31655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31656       };
31657     } catch (Dali::DaliException e) {
31658       {
31659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31660       };
31661     } catch (...) {
31662       {
31663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31664       };
31665     }
31666   }
31667
31668   jresult = (void *)result;
31669   return jresult;
31670 }
31671
31672
31673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31674   void * jresult ;
31675   Dali::Gesture::State arg1 ;
31676   Dali::LongPressGesture *result = 0 ;
31677
31678   arg1 = (Dali::Gesture::State)jarg1;
31679   {
31680     try {
31681       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31682     } catch (std::out_of_range& e) {
31683       {
31684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31685       };
31686     } catch (std::exception& e) {
31687       {
31688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31689       };
31690     } catch (Dali::DaliException e) {
31691       {
31692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31693       };
31694     } catch (...) {
31695       {
31696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31697       };
31698     }
31699   }
31700
31701   jresult = (void *)result;
31702   return jresult;
31703 }
31704
31705
31706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31707   void * jresult ;
31708   Dali::LongPressGesture *arg1 = 0 ;
31709   Dali::LongPressGesture *result = 0 ;
31710
31711   arg1 = (Dali::LongPressGesture *)jarg1;
31712   if (!arg1) {
31713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31714     return 0;
31715   }
31716   {
31717     try {
31718       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31719     } catch (std::out_of_range& e) {
31720       {
31721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31722       };
31723     } catch (std::exception& e) {
31724       {
31725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31726       };
31727     } catch (Dali::DaliException e) {
31728       {
31729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31730       };
31731     } catch (...) {
31732       {
31733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31734       };
31735     }
31736   }
31737
31738   jresult = (void *)result;
31739   return jresult;
31740 }
31741
31742
31743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31744   void * jresult ;
31745   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31746   Dali::LongPressGesture *arg2 = 0 ;
31747   Dali::LongPressGesture *result = 0 ;
31748
31749   arg1 = (Dali::LongPressGesture *)jarg1;
31750   arg2 = (Dali::LongPressGesture *)jarg2;
31751   if (!arg2) {
31752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31753     return 0;
31754   }
31755   {
31756     try {
31757       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31758     } catch (std::out_of_range& e) {
31759       {
31760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31761       };
31762     } catch (std::exception& e) {
31763       {
31764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31765       };
31766     } catch (Dali::DaliException e) {
31767       {
31768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31769       };
31770     } catch (...) {
31771       {
31772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31773       };
31774     }
31775   }
31776
31777   jresult = (void *)result;
31778   return jresult;
31779 }
31780
31781
31782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
31783   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31784
31785   arg1 = (Dali::LongPressGesture *)jarg1;
31786   {
31787     try {
31788       delete arg1;
31789     } catch (std::out_of_range& e) {
31790       {
31791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31792       };
31793     } catch (std::exception& e) {
31794       {
31795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31796       };
31797     } catch (Dali::DaliException e) {
31798       {
31799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31800       };
31801     } catch (...) {
31802       {
31803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31804       };
31805     }
31806   }
31807
31808 }
31809
31810
31811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
31812   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31813   unsigned int arg2 ;
31814
31815   arg1 = (Dali::LongPressGesture *)jarg1;
31816   arg2 = (unsigned int)jarg2;
31817   if (arg1) (arg1)->numberOfTouches = arg2;
31818 }
31819
31820
31821 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
31822   unsigned int jresult ;
31823   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31824   unsigned int result;
31825
31826   arg1 = (Dali::LongPressGesture *)jarg1;
31827   result = (unsigned int) ((arg1)->numberOfTouches);
31828   jresult = result;
31829   return jresult;
31830 }
31831
31832
31833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
31834   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31835   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
31836
31837   arg1 = (Dali::LongPressGesture *)jarg1;
31838   arg2 = (Dali::Vector2 *)jarg2;
31839   if (arg1) (arg1)->screenPoint = *arg2;
31840 }
31841
31842
31843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
31844   void * jresult ;
31845   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31846   Dali::Vector2 *result = 0 ;
31847
31848   arg1 = (Dali::LongPressGesture *)jarg1;
31849   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
31850   jresult = (void *)result;
31851   return jresult;
31852 }
31853
31854
31855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
31856   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31857   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
31858
31859   arg1 = (Dali::LongPressGesture *)jarg1;
31860   arg2 = (Dali::Vector2 *)jarg2;
31861   if (arg1) (arg1)->localPoint = *arg2;
31862 }
31863
31864
31865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
31866   void * jresult ;
31867   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31868   Dali::Vector2 *result = 0 ;
31869
31870   arg1 = (Dali::LongPressGesture *)jarg1;
31871   result = (Dali::Vector2 *)& ((arg1)->localPoint);
31872   jresult = (void *)result;
31873   return jresult;
31874 }
31875
31876
31877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
31878   void * jresult ;
31879   Dali::WheelEvent *result = 0 ;
31880
31881   {
31882     try {
31883       result = (Dali::WheelEvent *)new Dali::WheelEvent();
31884     } catch (std::out_of_range& e) {
31885       {
31886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31887       };
31888     } catch (std::exception& e) {
31889       {
31890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31891       };
31892     } catch (Dali::DaliException e) {
31893       {
31894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31895       };
31896     } catch (...) {
31897       {
31898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31899       };
31900     }
31901   }
31902
31903   jresult = (void *)result;
31904   return jresult;
31905 }
31906
31907
31908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
31909   void * jresult ;
31910   Dali::WheelEvent::Type arg1 ;
31911   int arg2 ;
31912   unsigned int arg3 ;
31913   Dali::Vector2 arg4 ;
31914   int arg5 ;
31915   unsigned int arg6 ;
31916   Dali::Vector2 *argp4 ;
31917   Dali::WheelEvent *result = 0 ;
31918
31919   arg1 = (Dali::WheelEvent::Type)jarg1;
31920   arg2 = (int)jarg2;
31921   arg3 = (unsigned int)jarg3;
31922   argp4 = (Dali::Vector2 *)jarg4;
31923   if (!argp4) {
31924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
31925     return 0;
31926   }
31927   arg4 = *argp4;
31928   arg5 = (int)jarg5;
31929   arg6 = (unsigned int)jarg6;
31930   {
31931     try {
31932       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
31933     } catch (std::out_of_range& e) {
31934       {
31935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31936       };
31937     } catch (std::exception& e) {
31938       {
31939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31940       };
31941     } catch (Dali::DaliException e) {
31942       {
31943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31944       };
31945     } catch (...) {
31946       {
31947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31948       };
31949     }
31950   }
31951
31952   jresult = (void *)result;
31953   return jresult;
31954 }
31955
31956
31957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
31958   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
31959
31960   arg1 = (Dali::WheelEvent *)jarg1;
31961   {
31962     try {
31963       delete arg1;
31964     } catch (std::out_of_range& e) {
31965       {
31966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31967       };
31968     } catch (std::exception& e) {
31969       {
31970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31971       };
31972     } catch (Dali::DaliException e) {
31973       {
31974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31975       };
31976     } catch (...) {
31977       {
31978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31979       };
31980     }
31981   }
31982
31983 }
31984
31985
31986 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
31987   unsigned int jresult ;
31988   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
31989   bool result;
31990
31991   arg1 = (Dali::WheelEvent *)jarg1;
31992   {
31993     try {
31994       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
31995     } catch (std::out_of_range& e) {
31996       {
31997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31998       };
31999     } catch (std::exception& e) {
32000       {
32001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32002       };
32003     } catch (Dali::DaliException e) {
32004       {
32005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32006       };
32007     } catch (...) {
32008       {
32009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32010       };
32011     }
32012   }
32013
32014   jresult = result;
32015   return jresult;
32016 }
32017
32018
32019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32020   unsigned int jresult ;
32021   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32022   bool result;
32023
32024   arg1 = (Dali::WheelEvent *)jarg1;
32025   {
32026     try {
32027       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32028     } catch (std::out_of_range& e) {
32029       {
32030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32031       };
32032     } catch (std::exception& e) {
32033       {
32034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32035       };
32036     } catch (Dali::DaliException e) {
32037       {
32038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32039       };
32040     } catch (...) {
32041       {
32042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32043       };
32044     }
32045   }
32046
32047   jresult = result;
32048   return jresult;
32049 }
32050
32051
32052 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32053   unsigned int jresult ;
32054   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32055   bool result;
32056
32057   arg1 = (Dali::WheelEvent *)jarg1;
32058   {
32059     try {
32060       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32061     } catch (std::out_of_range& e) {
32062       {
32063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32064       };
32065     } catch (std::exception& e) {
32066       {
32067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32068       };
32069     } catch (Dali::DaliException e) {
32070       {
32071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32072       };
32073     } catch (...) {
32074       {
32075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32076       };
32077     }
32078   }
32079
32080   jresult = result;
32081   return jresult;
32082 }
32083
32084
32085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32086   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32087   Dali::WheelEvent::Type arg2 ;
32088
32089   arg1 = (Dali::WheelEvent *)jarg1;
32090   arg2 = (Dali::WheelEvent::Type)jarg2;
32091   if (arg1) (arg1)->type = arg2;
32092 }
32093
32094
32095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32096   int jresult ;
32097   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32098   Dali::WheelEvent::Type result;
32099
32100   arg1 = (Dali::WheelEvent *)jarg1;
32101   result = (Dali::WheelEvent::Type) ((arg1)->type);
32102   jresult = (int)result;
32103   return jresult;
32104 }
32105
32106
32107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32108   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32109   int arg2 ;
32110
32111   arg1 = (Dali::WheelEvent *)jarg1;
32112   arg2 = (int)jarg2;
32113   if (arg1) (arg1)->direction = arg2;
32114 }
32115
32116
32117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32118   int jresult ;
32119   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32120   int result;
32121
32122   arg1 = (Dali::WheelEvent *)jarg1;
32123   result = (int) ((arg1)->direction);
32124   jresult = result;
32125   return jresult;
32126 }
32127
32128
32129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32130   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32131   unsigned int arg2 ;
32132
32133   arg1 = (Dali::WheelEvent *)jarg1;
32134   arg2 = (unsigned int)jarg2;
32135   if (arg1) (arg1)->modifiers = arg2;
32136 }
32137
32138
32139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32140   unsigned int jresult ;
32141   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32142   unsigned int result;
32143
32144   arg1 = (Dali::WheelEvent *)jarg1;
32145   result = (unsigned int) ((arg1)->modifiers);
32146   jresult = result;
32147   return jresult;
32148 }
32149
32150
32151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32152   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32153   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32154
32155   arg1 = (Dali::WheelEvent *)jarg1;
32156   arg2 = (Dali::Vector2 *)jarg2;
32157   if (arg1) (arg1)->point = *arg2;
32158 }
32159
32160
32161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32162   void * jresult ;
32163   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32164   Dali::Vector2 *result = 0 ;
32165
32166   arg1 = (Dali::WheelEvent *)jarg1;
32167   result = (Dali::Vector2 *)& ((arg1)->point);
32168   jresult = (void *)result;
32169   return jresult;
32170 }
32171
32172
32173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32174   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32175   int arg2 ;
32176
32177   arg1 = (Dali::WheelEvent *)jarg1;
32178   arg2 = (int)jarg2;
32179   if (arg1) (arg1)->z = arg2;
32180 }
32181
32182
32183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32184   int jresult ;
32185   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32186   int result;
32187
32188   arg1 = (Dali::WheelEvent *)jarg1;
32189   result = (int) ((arg1)->z);
32190   jresult = result;
32191   return jresult;
32192 }
32193
32194
32195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32196   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32197   unsigned int arg2 ;
32198
32199   arg1 = (Dali::WheelEvent *)jarg1;
32200   arg2 = (unsigned int)jarg2;
32201   if (arg1) (arg1)->timeStamp = arg2;
32202 }
32203
32204
32205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32206   unsigned int jresult ;
32207   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32208   unsigned int result;
32209
32210   arg1 = (Dali::WheelEvent *)jarg1;
32211   result = (unsigned int) ((arg1)->timeStamp);
32212   jresult = result;
32213   return jresult;
32214 }
32215
32216 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32217   char * jresult ;
32218   Dali::KeyEvent *arg1 = 0 ;
32219   std::string result;
32220
32221   arg1 = (Dali::KeyEvent *)jarg1;
32222   if (!arg1) {
32223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32224     return 0;
32225   }
32226   {
32227     try {
32228       result = arg1->GetDeviceName();
32229     } catch (std::out_of_range& e) {
32230       {
32231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32232       };
32233     } catch (std::exception& e) {
32234       {
32235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32236       };
32237     } catch (Dali::DaliException e) {
32238       {
32239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32240       };
32241     } catch (...) {
32242       {
32243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32244       };
32245     }
32246   }
32247
32248   jresult = SWIG_csharp_string_callback((&result)->c_str());
32249   return jresult;
32250 }
32251
32252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32253   int jresult ;
32254   Dali::KeyEvent *arg1 = 0 ;
32255   Dali::Device::Class::Type result;
32256
32257   arg1 = (Dali::KeyEvent *)jarg1;
32258   if (!arg1) {
32259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32260     return 0;
32261   }
32262   {
32263     try {
32264       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32265     } catch (std::out_of_range& e) {
32266       {
32267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32268       };
32269     } catch (std::exception& e) {
32270       {
32271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32272       };
32273     } catch (Dali::DaliException e) {
32274       {
32275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32276       };
32277     } catch (...) {
32278       {
32279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32280       };
32281     }
32282   }
32283
32284   jresult = (int)result;
32285   return jresult;
32286 }
32287
32288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32289   int jresult ;
32290   Dali::KeyEvent *arg1 = 0 ;
32291   Dali::Device::Subclass::Type result;
32292
32293   arg1 = (Dali::KeyEvent *)jarg1;
32294   if (!arg1) {
32295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32296     return 0;
32297   }
32298   {
32299     try {
32300       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32301     } catch (std::out_of_range& e) {
32302       {
32303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32304       };
32305     } catch (std::exception& e) {
32306       {
32307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32308       };
32309     } catch (Dali::DaliException e) {
32310       {
32311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32312       };
32313     } catch (...) {
32314       {
32315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32316       };
32317     }
32318   }
32319
32320   jresult = (int)result;
32321   return jresult;
32322 }
32323
32324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32325   Dali::Actor arg1 ;
32326   Dali::Actor *argp1 ;
32327
32328   argp1 = (Dali::Actor *)jarg1;
32329   if (!argp1) {
32330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32331     return ;
32332   }
32333   arg1 = *argp1;
32334   {
32335     try {
32336       arg1.Raise();
32337     } catch (std::out_of_range& e) {
32338       {
32339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32340       };
32341     } catch (std::exception& e) {
32342       {
32343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32344       };
32345     } catch (Dali::DaliException e) {
32346       {
32347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32348       };
32349     } catch (...) {
32350       {
32351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32352       };
32353     }
32354   }
32355
32356 }
32357
32358
32359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32360   Dali::Actor arg1 ;
32361   Dali::Actor *argp1 ;
32362
32363   argp1 = (Dali::Actor *)jarg1;
32364   if (!argp1) {
32365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32366     return ;
32367   }
32368   arg1 = *argp1;
32369   {
32370     try {
32371       arg1.Lower();
32372     } catch (std::out_of_range& e) {
32373       {
32374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32375       };
32376     } catch (std::exception& e) {
32377       {
32378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32379       };
32380     } catch (Dali::DaliException e) {
32381       {
32382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32383       };
32384     } catch (...) {
32385       {
32386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32387       };
32388     }
32389   }
32390
32391 }
32392
32393
32394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32395   Dali::Actor arg1 ;
32396   Dali::Actor *argp1 ;
32397
32398   argp1 = (Dali::Actor *)jarg1;
32399   if (!argp1) {
32400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32401     return ;
32402   }
32403   arg1 = *argp1;
32404   {
32405     try {
32406       arg1.RaiseToTop();
32407     } catch (std::out_of_range& e) {
32408       {
32409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32410       };
32411     } catch (std::exception& e) {
32412       {
32413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32414       };
32415     } catch (Dali::DaliException e) {
32416       {
32417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32418       };
32419     } catch (...) {
32420       {
32421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32422       };
32423     }
32424   }
32425
32426 }
32427
32428
32429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32430   Dali::Actor arg1 ;
32431   Dali::Actor *argp1 ;
32432
32433   argp1 = (Dali::Actor *)jarg1;
32434   if (!argp1) {
32435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32436     return ;
32437   }
32438   arg1 = *argp1;
32439   {
32440     try {
32441       arg1.LowerToBottom();
32442     } catch (std::out_of_range& e) {
32443       {
32444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32445       };
32446     } catch (std::exception& e) {
32447       {
32448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32449       };
32450     } catch (Dali::DaliException e) {
32451       {
32452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32453       };
32454     } catch (...) {
32455       {
32456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32457       };
32458     }
32459   }
32460
32461 }
32462
32463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32464   Dali::Actor arg1 ;
32465   Dali::Actor arg2 ;
32466   Dali::Actor *argp1 ;
32467   Dali::Actor *argp2 ;
32468
32469   argp1 = (Dali::Actor *)jarg1;
32470   if (!argp1) {
32471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32472     return ;
32473   }
32474   arg1 = *argp1;
32475   argp2 = (Dali::Actor *)jarg2;
32476   if (!argp2) {
32477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32478     return ;
32479   }
32480   arg2 = *argp2;
32481   {
32482     try {
32483       arg1.RaiseAbove(arg2);
32484     } catch (std::out_of_range& e) {
32485       {
32486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32487       };
32488     } catch (std::exception& e) {
32489       {
32490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32491       };
32492     } catch (Dali::DaliException e) {
32493       {
32494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32495       };
32496     } catch (...) {
32497       {
32498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32499       };
32500     }
32501   }
32502
32503 }
32504
32505
32506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32507   Dali::Actor arg1 ;
32508   Dali::Actor arg2 ;
32509   Dali::Actor *argp1 ;
32510   Dali::Actor *argp2 ;
32511
32512   argp1 = (Dali::Actor *)jarg1;
32513   if (!argp1) {
32514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32515     return ;
32516   }
32517   arg1 = *argp1;
32518   argp2 = (Dali::Actor *)jarg2;
32519   if (!argp2) {
32520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32521     return ;
32522   }
32523   arg2 = *argp2;
32524   {
32525     try {
32526       arg1.LowerBelow(arg2);
32527     } catch (std::out_of_range& e) {
32528       {
32529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32530       };
32531     } catch (std::exception& e) {
32532       {
32533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32534       };
32535     } catch (Dali::DaliException e) {
32536       {
32537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32538       };
32539     } catch (...) {
32540       {
32541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32542       };
32543     }
32544   }
32545
32546 }
32547
32548
32549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32550   void * jresult ;
32551   Dali::Actor arg1 ;
32552   Dali::Actor *argp1 ;
32553   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32554
32555   argp1 = (Dali::Actor *)jarg1;
32556   if (!argp1) {
32557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32558     return 0;
32559   }
32560   arg1 = *argp1;
32561   {
32562     try {
32563       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32564     } catch (std::out_of_range& e) {
32565       {
32566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32567       };
32568     } catch (std::exception& e) {
32569       {
32570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32571       };
32572     } catch (Dali::DaliException e) {
32573       {
32574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32575       };
32576     } catch (...) {
32577       {
32578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32579       };
32580     }
32581   }
32582
32583   jresult = (void *)result;
32584   return jresult;
32585 }
32586
32587
32588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32589   void * jresult ;
32590   Dali::Actor *arg1 ;
32591   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32592
32593   arg1 = (Dali::Actor *)jarg1;
32594   {
32595     try {
32596       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32597     } catch (std::out_of_range& e) {
32598       {
32599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32600       };
32601     } catch (std::exception& e) {
32602       {
32603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32604       };
32605     } catch (Dali::DaliException e) {
32606       {
32607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32608       };
32609     } catch (...) {
32610       {
32611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32612       };
32613     }
32614   }
32615
32616   jresult = (void *)result;
32617   return jresult;
32618 }
32619
32620
32621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32622   int jresult ;
32623   int result;
32624
32625   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32626   jresult = (int)result;
32627   return jresult;
32628 }
32629
32630
32631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32632   int jresult ;
32633   int result;
32634
32635   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32636   jresult = (int)result;
32637   return jresult;
32638 }
32639
32640
32641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32642   int jresult ;
32643   int result;
32644
32645   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32646   jresult = (int)result;
32647   return jresult;
32648 }
32649
32650
32651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32652   int jresult ;
32653   int result;
32654
32655   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32656   jresult = (int)result;
32657   return jresult;
32658 }
32659
32660
32661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32662   int jresult ;
32663   int result;
32664
32665   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32666   jresult = (int)result;
32667   return jresult;
32668 }
32669
32670
32671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32672   int jresult ;
32673   int result;
32674
32675   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32676   jresult = (int)result;
32677   return jresult;
32678 }
32679
32680
32681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32682   int jresult ;
32683   int result;
32684
32685   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32686   jresult = (int)result;
32687   return jresult;
32688 }
32689
32690
32691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32692   int jresult ;
32693   int result;
32694
32695   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32696   jresult = (int)result;
32697   return jresult;
32698 }
32699
32700
32701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32702   int jresult ;
32703   int result;
32704
32705   result = (int)Dali::Actor::Property::SIZE;
32706   jresult = (int)result;
32707   return jresult;
32708 }
32709
32710
32711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32712   int jresult ;
32713   int result;
32714
32715   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32716   jresult = (int)result;
32717   return jresult;
32718 }
32719
32720
32721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32722   int jresult ;
32723   int result;
32724
32725   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32726   jresult = (int)result;
32727   return jresult;
32728 }
32729
32730
32731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32732   int jresult ;
32733   int result;
32734
32735   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32736   jresult = (int)result;
32737   return jresult;
32738 }
32739
32740
32741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32742   int jresult ;
32743   int result;
32744
32745   result = (int)Dali::Actor::Property::POSITION;
32746   jresult = (int)result;
32747   return jresult;
32748 }
32749
32750
32751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32752   int jresult ;
32753   int result;
32754
32755   result = (int)Dali::Actor::Property::POSITION_X;
32756   jresult = (int)result;
32757   return jresult;
32758 }
32759
32760
32761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
32762   int jresult ;
32763   int result;
32764
32765   result = (int)Dali::Actor::Property::POSITION_Y;
32766   jresult = (int)result;
32767   return jresult;
32768 }
32769
32770
32771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
32772   int jresult ;
32773   int result;
32774
32775   result = (int)Dali::Actor::Property::POSITION_Z;
32776   jresult = (int)result;
32777   return jresult;
32778 }
32779
32780
32781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
32782   int jresult ;
32783   int result;
32784
32785   result = (int)Dali::Actor::Property::WORLD_POSITION;
32786   jresult = (int)result;
32787   return jresult;
32788 }
32789
32790
32791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
32792   int jresult ;
32793   int result;
32794
32795   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
32796   jresult = (int)result;
32797   return jresult;
32798 }
32799
32800
32801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
32802   int jresult ;
32803   int result;
32804
32805   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
32806   jresult = (int)result;
32807   return jresult;
32808 }
32809
32810
32811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
32812   int jresult ;
32813   int result;
32814
32815   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
32816   jresult = (int)result;
32817   return jresult;
32818 }
32819
32820
32821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
32822   int jresult ;
32823   int result;
32824
32825   result = (int)Dali::Actor::Property::ORIENTATION;
32826   jresult = (int)result;
32827   return jresult;
32828 }
32829
32830
32831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
32832   int jresult ;
32833   int result;
32834
32835   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
32836   jresult = (int)result;
32837   return jresult;
32838 }
32839
32840
32841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
32842   int jresult ;
32843   int result;
32844
32845   result = (int)Dali::Actor::Property::SCALE;
32846   jresult = (int)result;
32847   return jresult;
32848 }
32849
32850
32851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
32852   int jresult ;
32853   int result;
32854
32855   result = (int)Dali::Actor::Property::SCALE_X;
32856   jresult = (int)result;
32857   return jresult;
32858 }
32859
32860
32861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
32862   int jresult ;
32863   int result;
32864
32865   result = (int)Dali::Actor::Property::SCALE_Y;
32866   jresult = (int)result;
32867   return jresult;
32868 }
32869
32870
32871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
32872   int jresult ;
32873   int result;
32874
32875   result = (int)Dali::Actor::Property::SCALE_Z;
32876   jresult = (int)result;
32877   return jresult;
32878 }
32879
32880
32881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
32882   int jresult ;
32883   int result;
32884
32885   result = (int)Dali::Actor::Property::WORLD_SCALE;
32886   jresult = (int)result;
32887   return jresult;
32888 }
32889
32890
32891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
32892   int jresult ;
32893   int result;
32894
32895   result = (int)Dali::Actor::Property::VISIBLE;
32896   jresult = (int)result;
32897   return jresult;
32898 }
32899
32900
32901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
32902   int jresult ;
32903   int result;
32904
32905   result = (int)Dali::Actor::Property::COLOR;
32906   jresult = (int)result;
32907   return jresult;
32908 }
32909
32910
32911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
32912   int jresult ;
32913   int result;
32914
32915   result = (int)Dali::Actor::Property::COLOR_RED;
32916   jresult = (int)result;
32917   return jresult;
32918 }
32919
32920
32921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
32922   int jresult ;
32923   int result;
32924
32925   result = (int)Dali::Actor::Property::COLOR_GREEN;
32926   jresult = (int)result;
32927   return jresult;
32928 }
32929
32930
32931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
32932   int jresult ;
32933   int result;
32934
32935   result = (int)Dali::Actor::Property::COLOR_BLUE;
32936   jresult = (int)result;
32937   return jresult;
32938 }
32939
32940
32941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
32942   int jresult ;
32943   int result;
32944
32945   result = (int)Dali::Actor::Property::COLOR_ALPHA;
32946   jresult = (int)result;
32947   return jresult;
32948 }
32949
32950
32951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
32952   int jresult ;
32953   int result;
32954
32955   result = (int)Dali::Actor::Property::WORLD_COLOR;
32956   jresult = (int)result;
32957   return jresult;
32958 }
32959
32960
32961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
32962   int jresult ;
32963   int result;
32964
32965   result = (int)Dali::Actor::Property::WORLD_MATRIX;
32966   jresult = (int)result;
32967   return jresult;
32968 }
32969
32970
32971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
32972   int jresult ;
32973   int result;
32974
32975   result = (int)Dali::Actor::Property::NAME;
32976   jresult = (int)result;
32977   return jresult;
32978 }
32979
32980
32981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
32982   int jresult ;
32983   int result;
32984
32985   result = (int)Dali::Actor::Property::SENSITIVE;
32986   jresult = (int)result;
32987   return jresult;
32988 }
32989
32990
32991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
32992   int jresult ;
32993   int result;
32994
32995   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
32996   jresult = (int)result;
32997   return jresult;
32998 }
32999
33000
33001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33002   int jresult ;
33003   int result;
33004
33005   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33006   jresult = (int)result;
33007   return jresult;
33008 }
33009
33010
33011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33012   int jresult ;
33013   int result;
33014
33015   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33016   jresult = (int)result;
33017   return jresult;
33018 }
33019
33020
33021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33022   int jresult ;
33023   int result;
33024
33025   result = (int)Dali::Actor::Property::COLOR_MODE;
33026   jresult = (int)result;
33027   return jresult;
33028 }
33029
33030
33031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33032   int jresult ;
33033   int result;
33034
33035   result = (int)Dali::Actor::Property::DRAW_MODE;
33036   jresult = (int)result;
33037   return jresult;
33038 }
33039
33040
33041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33042   int jresult ;
33043   int result;
33044
33045   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33046   jresult = (int)result;
33047   return jresult;
33048 }
33049
33050
33051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33052   int jresult ;
33053   int result;
33054
33055   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33056   jresult = (int)result;
33057   return jresult;
33058 }
33059
33060
33061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33062   int jresult ;
33063   int result;
33064
33065   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33066   jresult = (int)result;
33067   return jresult;
33068 }
33069
33070
33071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33072   int jresult ;
33073   int result;
33074
33075   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33076   jresult = (int)result;
33077   return jresult;
33078 }
33079
33080
33081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33082   int jresult ;
33083   int result;
33084
33085   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33086   jresult = (int)result;
33087   return jresult;
33088 }
33089
33090
33091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33092   int jresult ;
33093   int result;
33094
33095   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33096   jresult = (int)result;
33097   return jresult;
33098 }
33099
33100
33101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33102   int jresult ;
33103   int result;
33104
33105   result = (int)Dali::Actor::Property::PADDING;
33106   jresult = (int)result;
33107   return jresult;
33108 }
33109
33110
33111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33112   int jresult ;
33113   int result;
33114
33115   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33116   jresult = (int)result;
33117   return jresult;
33118 }
33119
33120
33121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33122   int jresult ;
33123   int result;
33124
33125   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33126   jresult = (int)result;
33127   return jresult;
33128 }
33129
33130
33131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33132   int jresult ;
33133   int result;
33134
33135   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33136   jresult = (int)result;
33137   return jresult;
33138 }
33139
33140
33141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33142   int jresult ;
33143   int result;
33144
33145   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33146   jresult = (int)result;
33147   return jresult;
33148 }
33149
33150 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
33151
33152   return Dali::Actor::Property::OPACITY;
33153 }
33154
33155 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() {
33156
33157   return Dali::Actor::Property::SCREEN_POSITION;
33158 }
33159
33160 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() {
33161
33162   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
33163 }
33164
33165 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() {
33166   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
33167 }
33168
33169 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() {
33170   return Dali::Actor::Property::LAYOUT_DIRECTION;
33171 }
33172
33173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33174   void * jresult ;
33175   Dali::Actor::Property *result = 0 ;
33176
33177   {
33178     try {
33179       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33180     } catch (std::out_of_range& e) {
33181       {
33182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33183       };
33184     } catch (std::exception& e) {
33185       {
33186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33187       };
33188     } catch (Dali::DaliException e) {
33189       {
33190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33191       };
33192     } catch (...) {
33193       {
33194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33195       };
33196     }
33197   }
33198
33199   jresult = (void *)result;
33200   return jresult;
33201 }
33202
33203
33204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33205   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33206
33207   arg1 = (Dali::Actor::Property *)jarg1;
33208   {
33209     try {
33210       delete arg1;
33211     } catch (std::out_of_range& e) {
33212       {
33213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33214       };
33215     } catch (std::exception& e) {
33216       {
33217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33218       };
33219     } catch (Dali::DaliException e) {
33220       {
33221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33222       };
33223     } catch (...) {
33224       {
33225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33226       };
33227     }
33228   }
33229
33230 }
33231
33232
33233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33234   void * jresult ;
33235   Dali::Actor *result = 0 ;
33236
33237   {
33238     try {
33239       result = (Dali::Actor *)new Dali::Actor();
33240     } catch (std::out_of_range& e) {
33241       {
33242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33243       };
33244     } catch (std::exception& e) {
33245       {
33246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33247       };
33248     } catch (Dali::DaliException e) {
33249       {
33250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33251       };
33252     } catch (...) {
33253       {
33254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33255       };
33256     }
33257   }
33258
33259   jresult = (void *)result;
33260   return jresult;
33261 }
33262
33263
33264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33265   void * jresult ;
33266   Dali::Actor result;
33267
33268   {
33269     try {
33270       result = Dali::Actor::New();
33271     } catch (std::out_of_range& e) {
33272       {
33273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33274       };
33275     } catch (std::exception& e) {
33276       {
33277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33278       };
33279     } catch (Dali::DaliException e) {
33280       {
33281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33282       };
33283     } catch (...) {
33284       {
33285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33286       };
33287     }
33288   }
33289
33290   jresult = new Dali::Actor((const Dali::Actor &)result);
33291   return jresult;
33292 }
33293
33294
33295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33296   void * jresult ;
33297   Dali::BaseHandle arg1 ;
33298   Dali::BaseHandle *argp1 ;
33299   Dali::Actor result;
33300
33301   argp1 = (Dali::BaseHandle *)jarg1;
33302   if (!argp1) {
33303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33304     return 0;
33305   }
33306   arg1 = *argp1;
33307   {
33308     try {
33309       result = Dali::Actor::DownCast(arg1);
33310     } catch (std::out_of_range& e) {
33311       {
33312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33313       };
33314     } catch (std::exception& e) {
33315       {
33316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33317       };
33318     } catch (Dali::DaliException e) {
33319       {
33320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33321       };
33322     } catch (...) {
33323       {
33324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33325       };
33326     }
33327   }
33328
33329   jresult = new Dali::Actor((const Dali::Actor &)result);
33330   return jresult;
33331 }
33332
33333
33334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33335   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33336
33337   arg1 = (Dali::Actor *)jarg1;
33338   {
33339     try {
33340       delete arg1;
33341     } catch (std::out_of_range& e) {
33342       {
33343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33344       };
33345     } catch (std::exception& e) {
33346       {
33347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33348       };
33349     } catch (Dali::DaliException e) {
33350       {
33351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33352       };
33353     } catch (...) {
33354       {
33355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33356       };
33357     }
33358   }
33359
33360 }
33361
33362
33363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33364   void * jresult ;
33365   Dali::Actor *arg1 = 0 ;
33366   Dali::Actor *result = 0 ;
33367
33368   arg1 = (Dali::Actor *)jarg1;
33369   if (!arg1) {
33370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33371     return 0;
33372   }
33373   {
33374     try {
33375       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33376     } catch (std::out_of_range& e) {
33377       {
33378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33379       };
33380     } catch (std::exception& e) {
33381       {
33382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33383       };
33384     } catch (Dali::DaliException e) {
33385       {
33386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33387       };
33388     } catch (...) {
33389       {
33390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33391       };
33392     }
33393   }
33394
33395   jresult = (void *)result;
33396   return jresult;
33397 }
33398
33399
33400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33401   void * jresult ;
33402   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33403   Dali::Actor *arg2 = 0 ;
33404   Dali::Actor *result = 0 ;
33405
33406   arg1 = (Dali::Actor *)jarg1;
33407   arg2 = (Dali::Actor *)jarg2;
33408   if (!arg2) {
33409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33410     return 0;
33411   }
33412   {
33413     try {
33414       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33415     } catch (std::out_of_range& e) {
33416       {
33417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33418       };
33419     } catch (std::exception& e) {
33420       {
33421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33422       };
33423     } catch (Dali::DaliException e) {
33424       {
33425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33426       };
33427     } catch (...) {
33428       {
33429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33430       };
33431     }
33432   }
33433
33434   jresult = (void *)result;
33435   return jresult;
33436 }
33437
33438
33439 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33440   char * jresult ;
33441   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33442   std::string *result = 0 ;
33443
33444   arg1 = (Dali::Actor *)jarg1;
33445   {
33446     try {
33447       std::string name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
33448       result = (std::string *) &name;
33449     } catch (std::out_of_range& e) {
33450       {
33451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33452       };
33453     } catch (std::exception& e) {
33454       {
33455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33456       };
33457     } catch (Dali::DaliException e) {
33458       {
33459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33460       };
33461     } catch (...) {
33462       {
33463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33464       };
33465     }
33466   }
33467
33468   jresult = SWIG_csharp_string_callback(result->c_str());
33469   return jresult;
33470 }
33471
33472
33473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33474   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33475   std::string *arg2 = 0 ;
33476
33477   arg1 = (Dali::Actor *)jarg1;
33478   if (!jarg2) {
33479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33480     return ;
33481   }
33482   std::string arg2_str(jarg2);
33483   arg2 = &arg2_str;
33484   {
33485     try {
33486       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
33487     } catch (std::out_of_range& e) {
33488       {
33489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33490       };
33491     } catch (std::exception& e) {
33492       {
33493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33494       };
33495     } catch (Dali::DaliException e) {
33496       {
33497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33498       };
33499     } catch (...) {
33500       {
33501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33502       };
33503     }
33504   }
33505
33506
33507   //argout typemap for const std::string&
33508
33509 }
33510
33511
33512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33513   unsigned int jresult ;
33514   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33515   unsigned int result;
33516
33517   arg1 = (Dali::Actor *)jarg1;
33518
33519   if(!arg1) {
33520     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
33521     return -1;
33522   }
33523
33524   {
33525     try {
33526       result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
33527     } catch (std::out_of_range& e) {
33528       {
33529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33530       };
33531     } catch (std::exception& e) {
33532       {
33533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33534       };
33535     } catch (Dali::DaliException e) {
33536       {
33537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33538       };
33539     } catch (...) {
33540       {
33541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33542       };
33543     }
33544   }
33545
33546   jresult = result;
33547   return jresult;
33548 }
33549
33550
33551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33552   unsigned int jresult ;
33553   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33554   bool result;
33555
33556   arg1 = (Dali::Actor *)jarg1;
33557   {
33558     try {
33559       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
33560     } catch (std::out_of_range& e) {
33561       {
33562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33563       };
33564     } catch (std::exception& e) {
33565       {
33566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33567       };
33568     } catch (Dali::DaliException e) {
33569       {
33570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33571       };
33572     } catch (...) {
33573       {
33574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33575       };
33576     }
33577   }
33578
33579   jresult = result;
33580   return jresult;
33581 }
33582
33583
33584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33585   unsigned int jresult ;
33586   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33587   bool result;
33588
33589   arg1 = (Dali::Actor *)jarg1;
33590   {
33591     try {
33592       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE );
33593     } catch (std::out_of_range& e) {
33594       {
33595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33596       };
33597     } catch (std::exception& e) {
33598       {
33599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33600       };
33601     } catch (Dali::DaliException e) {
33602       {
33603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33604       };
33605     } catch (...) {
33606       {
33607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33608       };
33609     }
33610   }
33611
33612   jresult = result;
33613   return jresult;
33614 }
33615
33616
33617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33618   unsigned int jresult ;
33619   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33620   bool result;
33621
33622   arg1 = (Dali::Actor *)jarg1;
33623   {
33624     try {
33625       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_LAYER );
33626     } catch (std::out_of_range& e) {
33627       {
33628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33629       };
33630     } catch (std::exception& e) {
33631       {
33632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33633       };
33634     } catch (Dali::DaliException e) {
33635       {
33636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33637       };
33638     } catch (...) {
33639       {
33640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33641       };
33642     }
33643   }
33644
33645   jresult = result;
33646   return jresult;
33647 }
33648
33649
33650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33651   void * jresult ;
33652   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33653   Dali::Layer result;
33654
33655   arg1 = (Dali::Actor *)jarg1;
33656   {
33657     try {
33658       result = (arg1)->GetLayer();
33659     } catch (std::out_of_range& e) {
33660       {
33661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33662       };
33663     } catch (std::exception& e) {
33664       {
33665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33666       };
33667     } catch (Dali::DaliException e) {
33668       {
33669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33670       };
33671     } catch (...) {
33672       {
33673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33674       };
33675     }
33676   }
33677
33678   jresult = new Dali::Layer((const Dali::Layer &)result);
33679   return jresult;
33680 }
33681
33682
33683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33684   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33685   Dali::Actor arg2 ;
33686   Dali::Actor *argp2 ;
33687
33688   arg1 = (Dali::Actor *)jarg1;
33689   argp2 = (Dali::Actor *)jarg2;
33690   if (!argp2) {
33691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33692     return ;
33693   }
33694   arg2 = *argp2;
33695   {
33696     try {
33697       (arg1)->Add(arg2);
33698     } catch (std::out_of_range& e) {
33699       {
33700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33701       };
33702     } catch (std::exception& e) {
33703       {
33704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33705       };
33706     } catch (Dali::DaliException e) {
33707       {
33708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33709       };
33710     } catch (...) {
33711       {
33712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33713       };
33714     }
33715   }
33716
33717 }
33718
33719
33720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33721   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33722   Dali::Actor arg2 ;
33723   Dali::Actor *argp2 ;
33724
33725   arg1 = (Dali::Actor *)jarg1;
33726   argp2 = (Dali::Actor *)jarg2;
33727   if (!argp2) {
33728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33729     return ;
33730   }
33731   arg2 = *argp2;
33732   {
33733     try {
33734       (arg1)->Remove(arg2);
33735     } catch (std::out_of_range& e) {
33736       {
33737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33738       };
33739     } catch (std::exception& e) {
33740       {
33741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33742       };
33743     } catch (Dali::DaliException e) {
33744       {
33745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33746       };
33747     } catch (...) {
33748       {
33749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33750       };
33751     }
33752   }
33753
33754 }
33755
33756
33757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33758   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33759
33760   arg1 = (Dali::Actor *)jarg1;
33761   {
33762     try {
33763       (arg1)->Unparent();
33764     } catch (std::out_of_range& e) {
33765       {
33766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33767       };
33768     } catch (std::exception& e) {
33769       {
33770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33771       };
33772     } catch (Dali::DaliException e) {
33773       {
33774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33775       };
33776     } catch (...) {
33777       {
33778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33779       };
33780     }
33781   }
33782
33783 }
33784
33785
33786 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
33787   unsigned int jresult ;
33788   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33789   unsigned int result;
33790
33791   arg1 = (Dali::Actor *)jarg1;
33792   {
33793     try {
33794       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
33795     } catch (std::out_of_range& e) {
33796       {
33797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33798       };
33799     } catch (std::exception& e) {
33800       {
33801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33802       };
33803     } catch (Dali::DaliException e) {
33804       {
33805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33806       };
33807     } catch (...) {
33808       {
33809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33810       };
33811     }
33812   }
33813
33814   jresult = result;
33815   return jresult;
33816 }
33817
33818
33819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
33820   void * jresult ;
33821   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33822   unsigned int arg2 ;
33823   Dali::Actor result;
33824
33825   arg1 = (Dali::Actor *)jarg1;
33826   arg2 = (unsigned int)jarg2;
33827   {
33828     try {
33829       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
33830     } catch (std::out_of_range& e) {
33831       {
33832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33833       };
33834     } catch (std::exception& e) {
33835       {
33836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33837       };
33838     } catch (Dali::DaliException e) {
33839       {
33840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33841       };
33842     } catch (...) {
33843       {
33844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33845       };
33846     }
33847   }
33848
33849   jresult = new Dali::Actor((const Dali::Actor &)result);
33850   return jresult;
33851 }
33852
33853
33854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
33855   void * jresult ;
33856   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33857   std::string *arg2 = 0 ;
33858   Dali::Actor result;
33859
33860   arg1 = (Dali::Actor *)jarg1;
33861   if (!jarg2) {
33862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33863     return 0;
33864   }
33865   std::string arg2_str(jarg2);
33866   arg2 = &arg2_str;
33867   {
33868     try {
33869       result = (arg1)->FindChildByName((std::string const &)*arg2);
33870     } catch (std::out_of_range& e) {
33871       {
33872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33873       };
33874     } catch (std::exception& e) {
33875       {
33876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33877       };
33878     } catch (Dali::DaliException e) {
33879       {
33880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33881       };
33882     } catch (...) {
33883       {
33884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33885       };
33886     }
33887   }
33888
33889   jresult = new Dali::Actor((const Dali::Actor &)result);
33890
33891   //argout typemap for const std::string&
33892
33893   return jresult;
33894 }
33895
33896
33897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
33898   void * jresult ;
33899   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33900   unsigned int arg2 ;
33901   Dali::Actor result;
33902
33903   arg1 = (Dali::Actor *)jarg1;
33904   arg2 = (unsigned int)jarg2;
33905   {
33906     try {
33907       result = (arg1)->FindChildById(arg2);
33908     } catch (std::out_of_range& e) {
33909       {
33910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33911       };
33912     } catch (std::exception& e) {
33913       {
33914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33915       };
33916     } catch (Dali::DaliException e) {
33917       {
33918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33919       };
33920     } catch (...) {
33921       {
33922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33923       };
33924     }
33925   }
33926
33927   jresult = new Dali::Actor((const Dali::Actor &)result);
33928   return jresult;
33929 }
33930
33931
33932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
33933   void * jresult ;
33934   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33935   Dali::Actor result;
33936
33937   arg1 = (Dali::Actor *)jarg1;
33938   {
33939     try {
33940       result = ((Dali::Actor const *)arg1)->GetParent();
33941     } catch (std::out_of_range& e) {
33942       {
33943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33944       };
33945     } catch (std::exception& e) {
33946       {
33947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33948       };
33949     } catch (Dali::DaliException e) {
33950       {
33951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33952       };
33953     } catch (...) {
33954       {
33955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33956       };
33957     }
33958   }
33959
33960   jresult = new Dali::Actor((const Dali::Actor &)result);
33961   return jresult;
33962 }
33963
33964
33965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
33966   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33967   Dali::Vector3 *arg2 = 0 ;
33968
33969   arg1 = (Dali::Actor *)jarg1;
33970   arg2 = (Dali::Vector3 *)jarg2;
33971   if (!arg2) {
33972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
33973     return ;
33974   }
33975   {
33976     try {
33977       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
33978     } catch (std::out_of_range& e) {
33979       {
33980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33981       };
33982     } catch (std::exception& e) {
33983       {
33984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33985       };
33986     } catch (Dali::DaliException e) {
33987       {
33988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33989       };
33990     } catch (...) {
33991       {
33992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33993       };
33994     }
33995   }
33996
33997 }
33998
33999
34000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34001   void * jresult ;
34002   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34003   Dali::Vector3 result;
34004
34005   arg1 = (Dali::Actor *)jarg1;
34006   {
34007     try {
34008       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
34009     } catch (std::out_of_range& e) {
34010       {
34011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34012       };
34013     } catch (std::exception& e) {
34014       {
34015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34016       };
34017     } catch (Dali::DaliException e) {
34018       {
34019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34020       };
34021     } catch (...) {
34022       {
34023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34024       };
34025     }
34026   }
34027
34028   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34029   return jresult;
34030 }
34031
34032
34033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34034   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34035   Dali::Vector3 *arg2 = 0 ;
34036
34037   arg1 = (Dali::Actor *)jarg1;
34038   arg2 = (Dali::Vector3 *)jarg2;
34039   if (!arg2) {
34040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34041     return ;
34042   }
34043   {
34044     try {
34045       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
34046     } catch (std::out_of_range& e) {
34047       {
34048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34049       };
34050     } catch (std::exception& e) {
34051       {
34052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34053       };
34054     } catch (Dali::DaliException e) {
34055       {
34056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34057       };
34058     } catch (...) {
34059       {
34060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34061       };
34062     }
34063   }
34064
34065 }
34066
34067
34068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34069   void * jresult ;
34070   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34071   Dali::Vector3 result;
34072
34073   arg1 = (Dali::Actor *)jarg1;
34074   {
34075     try {
34076       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
34077     } catch (std::out_of_range& e) {
34078       {
34079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34080       };
34081     } catch (std::exception& e) {
34082       {
34083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34084       };
34085     } catch (Dali::DaliException e) {
34086       {
34087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34088       };
34089     } catch (...) {
34090       {
34091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34092       };
34093     }
34094   }
34095
34096   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34097   return jresult;
34098 }
34099
34100
34101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34102   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34103   float arg2 ;
34104   float arg3 ;
34105
34106   arg1 = (Dali::Actor *)jarg1;
34107   arg2 = (float)jarg2;
34108   arg3 = (float)jarg3;
34109   {
34110     try {
34111       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
34112     } catch (std::out_of_range& e) {
34113       {
34114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34115       };
34116     } catch (std::exception& e) {
34117       {
34118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34119       };
34120     } catch (Dali::DaliException e) {
34121       {
34122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34123       };
34124     } catch (...) {
34125       {
34126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34127       };
34128     }
34129   }
34130
34131 }
34132
34133
34134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34135   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34136   float arg2 ;
34137   float arg3 ;
34138   float arg4 ;
34139
34140   arg1 = (Dali::Actor *)jarg1;
34141   arg2 = (float)jarg2;
34142   arg3 = (float)jarg3;
34143   arg4 = (float)jarg4;
34144   {
34145     try {
34146       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
34147     } catch (std::out_of_range& e) {
34148       {
34149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34150       };
34151     } catch (std::exception& e) {
34152       {
34153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34154       };
34155     } catch (Dali::DaliException e) {
34156       {
34157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34158       };
34159     } catch (...) {
34160       {
34161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34162       };
34163     }
34164   }
34165
34166 }
34167
34168
34169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34170   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34171   Dali::Vector2 *arg2 = 0 ;
34172
34173   arg1 = (Dali::Actor *)jarg1;
34174   arg2 = (Dali::Vector2 *)jarg2;
34175   if (!arg2) {
34176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34177     return ;
34178   }
34179   {
34180     try {
34181       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
34182     } catch (std::out_of_range& e) {
34183       {
34184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34185       };
34186     } catch (std::exception& e) {
34187       {
34188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34189       };
34190     } catch (Dali::DaliException e) {
34191       {
34192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34193       };
34194     } catch (...) {
34195       {
34196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34197       };
34198     }
34199   }
34200
34201 }
34202
34203
34204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34205   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34206   Dali::Vector3 *arg2 = 0 ;
34207
34208   arg1 = (Dali::Actor *)jarg1;
34209   arg2 = (Dali::Vector3 *)jarg2;
34210   if (!arg2) {
34211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34212     return ;
34213   }
34214   {
34215     try {
34216       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
34217     } catch (std::out_of_range& e) {
34218       {
34219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34220       };
34221     } catch (std::exception& e) {
34222       {
34223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34224       };
34225     } catch (Dali::DaliException e) {
34226       {
34227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34228       };
34229     } catch (...) {
34230       {
34231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34232       };
34233     }
34234   }
34235
34236 }
34237
34238
34239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34240   void * jresult ;
34241   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34242   Dali::Vector3 result;
34243
34244   arg1 = (Dali::Actor *)jarg1;
34245   {
34246     try {
34247       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34248     } catch (std::out_of_range& e) {
34249       {
34250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34251       };
34252     } catch (std::exception& e) {
34253       {
34254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34255       };
34256     } catch (Dali::DaliException e) {
34257       {
34258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34259       };
34260     } catch (...) {
34261       {
34262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34263       };
34264     }
34265   }
34266
34267   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34268   return jresult;
34269 }
34270
34271
34272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34273   void * jresult ;
34274   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34275   Dali::Vector3 result;
34276
34277   arg1 = (Dali::Actor *)jarg1;
34278   {
34279     try {
34280       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
34281     } catch (std::out_of_range& e) {
34282       {
34283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34284       };
34285     } catch (std::exception& e) {
34286       {
34287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34288       };
34289     } catch (Dali::DaliException e) {
34290       {
34291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34292       };
34293     } catch (...) {
34294       {
34295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34296       };
34297     }
34298   }
34299
34300   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34301   return jresult;
34302 }
34303
34304
34305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34306   void * jresult ;
34307   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34308   Dali::Vector3 result;
34309
34310   arg1 = (Dali::Actor *)jarg1;
34311   {
34312     try {
34313       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34314     } catch (std::out_of_range& e) {
34315       {
34316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34317       };
34318     } catch (std::exception& e) {
34319       {
34320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34321       };
34322     } catch (Dali::DaliException e) {
34323       {
34324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34325       };
34326     } catch (...) {
34327       {
34328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34329       };
34330     }
34331   }
34332
34333   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34334   return jresult;
34335 }
34336
34337
34338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34339   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34340   float arg2 ;
34341   float arg3 ;
34342
34343   arg1 = (Dali::Actor *)jarg1;
34344   arg2 = (float)jarg2;
34345   arg3 = (float)jarg3;
34346   {
34347     try {
34348       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
34349     } catch (std::out_of_range& e) {
34350       {
34351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34352       };
34353     } catch (std::exception& e) {
34354       {
34355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34356       };
34357     } catch (Dali::DaliException e) {
34358       {
34359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34360       };
34361     } catch (...) {
34362       {
34363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34364       };
34365     }
34366   }
34367
34368 }
34369
34370
34371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34372   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34373   float arg2 ;
34374   float arg3 ;
34375   float arg4 ;
34376
34377   arg1 = (Dali::Actor *)jarg1;
34378   arg2 = (float)jarg2;
34379   arg3 = (float)jarg3;
34380   arg4 = (float)jarg4;
34381   {
34382     try {
34383       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
34384     } catch (std::out_of_range& e) {
34385       {
34386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34387       };
34388     } catch (std::exception& e) {
34389       {
34390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34391       };
34392     } catch (Dali::DaliException e) {
34393       {
34394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34395       };
34396     } catch (...) {
34397       {
34398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34399       };
34400     }
34401   }
34402
34403 }
34404
34405
34406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34407   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34408   Dali::Vector3 *arg2 = 0 ;
34409
34410   arg1 = (Dali::Actor *)jarg1;
34411   arg2 = (Dali::Vector3 *)jarg2;
34412   if (!arg2) {
34413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34414     return ;
34415   }
34416   {
34417     try {
34418       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
34419     } catch (std::out_of_range& e) {
34420       {
34421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34422       };
34423     } catch (std::exception& e) {
34424       {
34425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34426       };
34427     } catch (Dali::DaliException e) {
34428       {
34429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34430       };
34431     } catch (...) {
34432       {
34433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34434       };
34435     }
34436   }
34437
34438 }
34439
34440
34441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34442   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34443   float arg2 ;
34444
34445   arg1 = (Dali::Actor *)jarg1;
34446   arg2 = (float)jarg2;
34447   {
34448     try {
34449       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
34450     } catch (std::out_of_range& e) {
34451       {
34452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34453       };
34454     } catch (std::exception& e) {
34455       {
34456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34457       };
34458     } catch (Dali::DaliException e) {
34459       {
34460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34461       };
34462     } catch (...) {
34463       {
34464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34465       };
34466     }
34467   }
34468
34469 }
34470
34471
34472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34473   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34474   float arg2 ;
34475
34476   arg1 = (Dali::Actor *)jarg1;
34477   arg2 = (float)jarg2;
34478   {
34479     try {
34480       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
34481     } catch (std::out_of_range& e) {
34482       {
34483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34484       };
34485     } catch (std::exception& e) {
34486       {
34487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34488       };
34489     } catch (Dali::DaliException e) {
34490       {
34491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34492       };
34493     } catch (...) {
34494       {
34495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34496       };
34497     }
34498   }
34499
34500 }
34501
34502
34503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34504   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34505   float arg2 ;
34506
34507   arg1 = (Dali::Actor *)jarg1;
34508   arg2 = (float)jarg2;
34509   {
34510     try {
34511       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
34512     } catch (std::out_of_range& e) {
34513       {
34514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34515       };
34516     } catch (std::exception& e) {
34517       {
34518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34519       };
34520     } catch (Dali::DaliException e) {
34521       {
34522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34523       };
34524     } catch (...) {
34525       {
34526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34527       };
34528     }
34529   }
34530
34531 }
34532
34533
34534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34535   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34536   Dali::Vector3 *arg2 = 0 ;
34537
34538   arg1 = (Dali::Actor *)jarg1;
34539   arg2 = (Dali::Vector3 *)jarg2;
34540   if (!arg2) {
34541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34542     return ;
34543   }
34544   {
34545     try {
34546       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34547     } catch (std::out_of_range& e) {
34548       {
34549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34550       };
34551     } catch (std::exception& e) {
34552       {
34553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34554       };
34555     } catch (Dali::DaliException e) {
34556       {
34557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34558       };
34559     } catch (...) {
34560       {
34561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34562       };
34563     }
34564   }
34565
34566 }
34567
34568
34569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34570   void * jresult ;
34571   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34572   Dali::Vector3 result;
34573
34574   arg1 = (Dali::Actor *)jarg1;
34575   {
34576     try {
34577       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
34578     } catch (std::out_of_range& e) {
34579       {
34580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34581       };
34582     } catch (std::exception& e) {
34583       {
34584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34585       };
34586     } catch (Dali::DaliException e) {
34587       {
34588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34589       };
34590     } catch (...) {
34591       {
34592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34593       };
34594     }
34595   }
34596
34597   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34598   return jresult;
34599 }
34600
34601
34602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34603   void * jresult ;
34604   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34605   Dali::Vector3 result;
34606
34607   arg1 = (Dali::Actor *)jarg1;
34608   {
34609     try {
34610       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
34611     } catch (std::out_of_range& e) {
34612       {
34613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34614       };
34615     } catch (std::exception& e) {
34616       {
34617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34618       };
34619     } catch (Dali::DaliException e) {
34620       {
34621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34622       };
34623     } catch (...) {
34624       {
34625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34626       };
34627     }
34628   }
34629
34630   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34631   return jresult;
34632 }
34633
34634
34635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34636   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34637   bool arg2 ;
34638
34639   arg1 = (Dali::Actor *)jarg1;
34640   arg2 = jarg2 ? true : false;
34641   {
34642     try {
34643       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
34644     } catch (std::out_of_range& e) {
34645       {
34646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34647       };
34648     } catch (std::exception& e) {
34649       {
34650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34651       };
34652     } catch (Dali::DaliException e) {
34653       {
34654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34655       };
34656     } catch (...) {
34657       {
34658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34659       };
34660     }
34661   }
34662
34663 }
34664
34665
34666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34667   unsigned int jresult ;
34668   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34669   bool result;
34670
34671   arg1 = (Dali::Actor *)jarg1;
34672   {
34673     try {
34674       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
34675     } catch (std::out_of_range& e) {
34676       {
34677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34678       };
34679     } catch (std::exception& e) {
34680       {
34681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34682       };
34683     } catch (Dali::DaliException e) {
34684       {
34685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34686       };
34687     } catch (...) {
34688       {
34689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34690       };
34691     }
34692   }
34693
34694   jresult = result;
34695   return jresult;
34696 }
34697
34698
34699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34700   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34701   Dali::Degree *arg2 = 0 ;
34702   Dali::Vector3 *arg3 = 0 ;
34703
34704   arg1 = (Dali::Actor *)jarg1;
34705   arg2 = (Dali::Degree *)jarg2;
34706   if (!arg2) {
34707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34708     return ;
34709   }
34710   arg3 = (Dali::Vector3 *)jarg3;
34711   if (!arg3) {
34712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34713     return ;
34714   }
34715   {
34716     try {
34717       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
34718     } catch (std::out_of_range& e) {
34719       {
34720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34721       };
34722     } catch (std::exception& e) {
34723       {
34724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34725       };
34726     } catch (Dali::DaliException e) {
34727       {
34728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34729       };
34730     } catch (...) {
34731       {
34732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34733       };
34734     }
34735   }
34736
34737 }
34738
34739
34740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34741   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34742   Dali::Radian *arg2 = 0 ;
34743   Dali::Vector3 *arg3 = 0 ;
34744
34745   arg1 = (Dali::Actor *)jarg1;
34746   arg2 = (Dali::Radian *)jarg2;
34747   if (!arg2) {
34748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34749     return ;
34750   }
34751   arg3 = (Dali::Vector3 *)jarg3;
34752   if (!arg3) {
34753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34754     return ;
34755   }
34756   {
34757     try {
34758       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
34759     } catch (std::out_of_range& e) {
34760       {
34761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34762       };
34763     } catch (std::exception& e) {
34764       {
34765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34766       };
34767     } catch (Dali::DaliException e) {
34768       {
34769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34770       };
34771     } catch (...) {
34772       {
34773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34774       };
34775     }
34776   }
34777
34778 }
34779
34780
34781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
34782   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34783   Dali::Quaternion *arg2 = 0 ;
34784
34785   arg1 = (Dali::Actor *)jarg1;
34786   arg2 = (Dali::Quaternion *)jarg2;
34787   if (!arg2) {
34788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34789     return ;
34790   }
34791   {
34792     try {
34793       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
34794     } catch (std::out_of_range& e) {
34795       {
34796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34797       };
34798     } catch (std::exception& e) {
34799       {
34800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34801       };
34802     } catch (Dali::DaliException e) {
34803       {
34804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34805       };
34806     } catch (...) {
34807       {
34808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34809       };
34810     }
34811   }
34812
34813 }
34814
34815
34816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34817   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34818   Dali::Degree *arg2 = 0 ;
34819   Dali::Vector3 *arg3 = 0 ;
34820
34821   arg1 = (Dali::Actor *)jarg1;
34822   arg2 = (Dali::Degree *)jarg2;
34823   if (!arg2) {
34824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34825     return ;
34826   }
34827   arg3 = (Dali::Vector3 *)jarg3;
34828   if (!arg3) {
34829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34830     return ;
34831   }
34832   {
34833     try {
34834       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34835     } catch (std::out_of_range& e) {
34836       {
34837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34838       };
34839     } catch (std::exception& e) {
34840       {
34841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34842       };
34843     } catch (Dali::DaliException e) {
34844       {
34845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34846       };
34847     } catch (...) {
34848       {
34849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34850       };
34851     }
34852   }
34853
34854 }
34855
34856
34857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34858   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34859   Dali::Radian *arg2 = 0 ;
34860   Dali::Vector3 *arg3 = 0 ;
34861
34862   arg1 = (Dali::Actor *)jarg1;
34863   arg2 = (Dali::Radian *)jarg2;
34864   if (!arg2) {
34865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34866     return ;
34867   }
34868   arg3 = (Dali::Vector3 *)jarg3;
34869   if (!arg3) {
34870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34871     return ;
34872   }
34873   {
34874     try {
34875       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
34876     } catch (std::out_of_range& e) {
34877       {
34878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34879       };
34880     } catch (std::exception& e) {
34881       {
34882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34883       };
34884     } catch (Dali::DaliException e) {
34885       {
34886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34887       };
34888     } catch (...) {
34889       {
34890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34891       };
34892     }
34893   }
34894
34895 }
34896
34897
34898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
34899   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34900   Dali::Quaternion *arg2 = 0 ;
34901
34902   arg1 = (Dali::Actor *)jarg1;
34903   arg2 = (Dali::Quaternion *)jarg2;
34904   if (!arg2) {
34905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34906     return ;
34907   }
34908   {
34909     try {
34910       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
34911     } catch (std::out_of_range& e) {
34912       {
34913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34914       };
34915     } catch (std::exception& e) {
34916       {
34917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34918       };
34919     } catch (Dali::DaliException e) {
34920       {
34921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34922       };
34923     } catch (...) {
34924       {
34925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34926       };
34927     }
34928   }
34929
34930 }
34931
34932
34933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
34934   void * jresult ;
34935   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34936   Dali::Quaternion result;
34937
34938   arg1 = (Dali::Actor *)jarg1;
34939   {
34940     try {
34941       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
34942     } catch (std::out_of_range& e) {
34943       {
34944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34945       };
34946     } catch (std::exception& e) {
34947       {
34948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34949       };
34950     } catch (Dali::DaliException e) {
34951       {
34952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34953       };
34954     } catch (...) {
34955       {
34956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34957       };
34958     }
34959   }
34960
34961   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
34962   return jresult;
34963 }
34964
34965
34966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
34967   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34968   bool arg2 ;
34969
34970   arg1 = (Dali::Actor *)jarg1;
34971   arg2 = jarg2 ? true : false;
34972   {
34973     try {
34974       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
34975     } catch (std::out_of_range& e) {
34976       {
34977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34978       };
34979     } catch (std::exception& e) {
34980       {
34981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34982       };
34983     } catch (Dali::DaliException e) {
34984       {
34985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34986       };
34987     } catch (...) {
34988       {
34989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34990       };
34991     }
34992   }
34993
34994 }
34995
34996
34997 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
34998   unsigned int jresult ;
34999   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35000   bool result;
35001
35002   arg1 = (Dali::Actor *)jarg1;
35003   {
35004     try {
35005       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
35006     } catch (std::out_of_range& e) {
35007       {
35008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35009       };
35010     } catch (std::exception& e) {
35011       {
35012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35013       };
35014     } catch (Dali::DaliException e) {
35015       {
35016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35017       };
35018     } catch (...) {
35019       {
35020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35021       };
35022     }
35023   }
35024
35025   jresult = result;
35026   return jresult;
35027 }
35028
35029
35030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35031   void * jresult ;
35032   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35033   Dali::Quaternion result;
35034
35035   arg1 = (Dali::Actor *)jarg1;
35036   {
35037     try {
35038       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
35039     } catch (std::out_of_range& e) {
35040       {
35041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35042       };
35043     } catch (std::exception& e) {
35044       {
35045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35046       };
35047     } catch (Dali::DaliException e) {
35048       {
35049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35050       };
35051     } catch (...) {
35052       {
35053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35054       };
35055     }
35056   }
35057
35058   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35059   return jresult;
35060 }
35061
35062
35063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35064   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35065   float arg2 ;
35066
35067   arg1 = (Dali::Actor *)jarg1;
35068   arg2 = (float)jarg2;
35069   {
35070     try {
35071       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
35072     } catch (std::out_of_range& e) {
35073       {
35074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35075       };
35076     } catch (std::exception& e) {
35077       {
35078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35079       };
35080     } catch (Dali::DaliException e) {
35081       {
35082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35083       };
35084     } catch (...) {
35085       {
35086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35087       };
35088     }
35089   }
35090
35091 }
35092
35093
35094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35095   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35096   float arg2 ;
35097   float arg3 ;
35098   float arg4 ;
35099
35100   arg1 = (Dali::Actor *)jarg1;
35101   arg2 = (float)jarg2;
35102   arg3 = (float)jarg3;
35103   arg4 = (float)jarg4;
35104   {
35105     try {
35106       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
35107     } catch (std::out_of_range& e) {
35108       {
35109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35110       };
35111     } catch (std::exception& e) {
35112       {
35113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35114       };
35115     } catch (Dali::DaliException e) {
35116       {
35117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35118       };
35119     } catch (...) {
35120       {
35121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35122       };
35123     }
35124   }
35125
35126 }
35127
35128
35129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35130   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35131   Dali::Vector3 *arg2 = 0 ;
35132
35133   arg1 = (Dali::Actor *)jarg1;
35134   arg2 = (Dali::Vector3 *)jarg2;
35135   if (!arg2) {
35136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35137     return ;
35138   }
35139   {
35140     try {
35141       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
35142     } catch (std::out_of_range& e) {
35143       {
35144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35145       };
35146     } catch (std::exception& e) {
35147       {
35148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35149       };
35150     } catch (Dali::DaliException e) {
35151       {
35152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35153       };
35154     } catch (...) {
35155       {
35156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35157       };
35158     }
35159   }
35160
35161 }
35162
35163
35164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35165   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35166   Dali::Vector3 *arg2 = 0 ;
35167
35168   arg1 = (Dali::Actor *)jarg1;
35169   arg2 = (Dali::Vector3 *)jarg2;
35170   if (!arg2) {
35171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35172     return ;
35173   }
35174   {
35175     try {
35176       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35177     } catch (std::out_of_range& e) {
35178       {
35179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35180       };
35181     } catch (std::exception& e) {
35182       {
35183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35184       };
35185     } catch (Dali::DaliException e) {
35186       {
35187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35188       };
35189     } catch (...) {
35190       {
35191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35192       };
35193     }
35194   }
35195
35196 }
35197
35198
35199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35200   void * jresult ;
35201   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35202   Dali::Vector3 result;
35203
35204   arg1 = (Dali::Actor *)jarg1;
35205   {
35206     try {
35207       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
35208     } catch (std::out_of_range& e) {
35209       {
35210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35211       };
35212     } catch (std::exception& e) {
35213       {
35214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35215       };
35216     } catch (Dali::DaliException e) {
35217       {
35218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35219       };
35220     } catch (...) {
35221       {
35222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35223       };
35224     }
35225   }
35226
35227   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35228   return jresult;
35229 }
35230
35231
35232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35233   void * jresult ;
35234   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35235   Dali::Vector3 result;
35236
35237   arg1 = (Dali::Actor *)jarg1;
35238   {
35239     try {
35240       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
35241     } catch (std::out_of_range& e) {
35242       {
35243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35244       };
35245     } catch (std::exception& e) {
35246       {
35247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35248       };
35249     } catch (Dali::DaliException e) {
35250       {
35251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35252       };
35253     } catch (...) {
35254       {
35255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35256       };
35257     }
35258   }
35259
35260   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35261   return jresult;
35262 }
35263
35264
35265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35266   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35267   bool arg2 ;
35268
35269   arg1 = (Dali::Actor *)jarg1;
35270   arg2 = jarg2 ? true : false;
35271   {
35272     try {
35273       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
35274     } catch (std::out_of_range& e) {
35275       {
35276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35277       };
35278     } catch (std::exception& e) {
35279       {
35280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35281       };
35282     } catch (Dali::DaliException e) {
35283       {
35284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35285       };
35286     } catch (...) {
35287       {
35288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35289       };
35290     }
35291   }
35292
35293 }
35294
35295
35296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35297   unsigned int jresult ;
35298   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35299   bool result;
35300
35301   arg1 = (Dali::Actor *)jarg1;
35302   {
35303     try {
35304       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
35305     } catch (std::out_of_range& e) {
35306       {
35307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35308       };
35309     } catch (std::exception& e) {
35310       {
35311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35312       };
35313     } catch (Dali::DaliException e) {
35314       {
35315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35316       };
35317     } catch (...) {
35318       {
35319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35320       };
35321     }
35322   }
35323
35324   jresult = result;
35325   return jresult;
35326 }
35327
35328
35329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35330   void * jresult ;
35331   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35332   Dali::Matrix result;
35333
35334   arg1 = (Dali::Actor *)jarg1;
35335   {
35336     try {
35337       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
35338     } catch (std::out_of_range& e) {
35339       {
35340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35341       };
35342     } catch (std::exception& e) {
35343       {
35344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35345       };
35346     } catch (Dali::DaliException e) {
35347       {
35348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35349       };
35350     } catch (...) {
35351       {
35352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35353       };
35354     }
35355   }
35356
35357   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35358   return jresult;
35359 }
35360
35361
35362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35363   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35364   bool arg2 ;
35365
35366   arg1 = (Dali::Actor *)jarg1;
35367   arg2 = jarg2 ? true : false;
35368   {
35369     try {
35370       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
35371     } catch (std::out_of_range& e) {
35372       {
35373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35374       };
35375     } catch (std::exception& e) {
35376       {
35377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35378       };
35379     } catch (Dali::DaliException e) {
35380       {
35381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35382       };
35383     } catch (...) {
35384       {
35385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35386       };
35387     }
35388   }
35389
35390 }
35391
35392
35393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35394   unsigned int jresult ;
35395   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35396   bool result;
35397
35398   arg1 = (Dali::Actor *)jarg1;
35399   {
35400     try {
35401       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
35402     } catch (std::out_of_range& e) {
35403       {
35404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35405       };
35406     } catch (std::exception& e) {
35407       {
35408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35409       };
35410     } catch (Dali::DaliException e) {
35411       {
35412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35413       };
35414     } catch (...) {
35415       {
35416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35417       };
35418     }
35419   }
35420
35421   jresult = result;
35422   return jresult;
35423 }
35424
35425
35426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35427   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35428   float arg2 ;
35429
35430   arg1 = (Dali::Actor *)jarg1;
35431   arg2 = (float)jarg2;
35432   {
35433     try {
35434       (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
35435     } catch (std::out_of_range& e) {
35436       {
35437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35438       };
35439     } catch (std::exception& e) {
35440       {
35441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35442       };
35443     } catch (Dali::DaliException e) {
35444       {
35445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35446       };
35447     } catch (...) {
35448       {
35449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35450       };
35451     }
35452   }
35453
35454 }
35455
35456
35457 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35458   float jresult ;
35459   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35460   float result;
35461
35462   arg1 = (Dali::Actor *)jarg1;
35463   {
35464     try {
35465       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
35466     } catch (std::out_of_range& e) {
35467       {
35468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35469       };
35470     } catch (std::exception& e) {
35471       {
35472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35473       };
35474     } catch (Dali::DaliException e) {
35475       {
35476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35477       };
35478     } catch (...) {
35479       {
35480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35481       };
35482     }
35483   }
35484
35485   jresult = result;
35486   return jresult;
35487 }
35488
35489
35490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35491   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35492   Dali::Vector4 *arg2 = 0 ;
35493
35494   arg1 = (Dali::Actor *)jarg1;
35495   arg2 = (Dali::Vector4 *)jarg2;
35496   if (!arg2) {
35497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35498     return ;
35499   }
35500   {
35501     try {
35502       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
35503     } catch (std::out_of_range& e) {
35504       {
35505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35506       };
35507     } catch (std::exception& e) {
35508       {
35509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35510       };
35511     } catch (Dali::DaliException e) {
35512       {
35513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35514       };
35515     } catch (...) {
35516       {
35517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35518       };
35519     }
35520   }
35521
35522 }
35523
35524
35525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35526   void * jresult ;
35527   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35528   Dali::Vector4 result;
35529
35530   arg1 = (Dali::Actor *)jarg1;
35531   {
35532     try {
35533       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
35534     } catch (std::out_of_range& e) {
35535       {
35536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35537       };
35538     } catch (std::exception& e) {
35539       {
35540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35541       };
35542     } catch (Dali::DaliException e) {
35543       {
35544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35545       };
35546     } catch (...) {
35547       {
35548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35549       };
35550     }
35551   }
35552
35553   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35554   return jresult;
35555 }
35556
35557
35558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35559   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35560   Dali::ColorMode arg2 ;
35561
35562   arg1 = (Dali::Actor *)jarg1;
35563   arg2 = (Dali::ColorMode)jarg2;
35564   {
35565     try {
35566       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
35567     } catch (std::out_of_range& e) {
35568       {
35569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35570       };
35571     } catch (std::exception& e) {
35572       {
35573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35574       };
35575     } catch (Dali::DaliException e) {
35576       {
35577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35578       };
35579     } catch (...) {
35580       {
35581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35582       };
35583     }
35584   }
35585
35586 }
35587
35588
35589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35590   int jresult ;
35591   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35592   Dali::ColorMode result;
35593
35594   arg1 = (Dali::Actor *)jarg1;
35595   {
35596     try {
35597       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
35598     } catch (std::out_of_range& e) {
35599       {
35600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35601       };
35602     } catch (std::exception& e) {
35603       {
35604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35605       };
35606     } catch (Dali::DaliException e) {
35607       {
35608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35609       };
35610     } catch (...) {
35611       {
35612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35613       };
35614     }
35615   }
35616
35617   jresult = (int)result;
35618   return jresult;
35619 }
35620
35621
35622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35623   void * jresult ;
35624   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35625   Dali::Vector4 result;
35626
35627   arg1 = (Dali::Actor *)jarg1;
35628   {
35629     try {
35630       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
35631     } catch (std::out_of_range& e) {
35632       {
35633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35634       };
35635     } catch (std::exception& e) {
35636       {
35637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35638       };
35639     } catch (Dali::DaliException e) {
35640       {
35641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35642       };
35643     } catch (...) {
35644       {
35645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35646       };
35647     }
35648   }
35649
35650   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35651   return jresult;
35652 }
35653
35654
35655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35656   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35657   Dali::DrawMode::Type arg2 ;
35658
35659   arg1 = (Dali::Actor *)jarg1;
35660   arg2 = (Dali::DrawMode::Type)jarg2;
35661   {
35662     try {
35663       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
35664     } catch (std::out_of_range& e) {
35665       {
35666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35667       };
35668     } catch (std::exception& e) {
35669       {
35670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35671       };
35672     } catch (Dali::DaliException e) {
35673       {
35674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35675       };
35676     } catch (...) {
35677       {
35678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35679       };
35680     }
35681   }
35682
35683 }
35684
35685
35686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35687   int jresult ;
35688   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35689   Dali::DrawMode::Type result;
35690
35691   arg1 = (Dali::Actor *)jarg1;
35692   {
35693     try {
35694       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
35695     } catch (std::out_of_range& e) {
35696       {
35697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35698       };
35699     } catch (std::exception& e) {
35700       {
35701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35702       };
35703     } catch (Dali::DaliException e) {
35704       {
35705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35706       };
35707     } catch (...) {
35708       {
35709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35710       };
35711     }
35712   }
35713
35714   jresult = (int)result;
35715   return jresult;
35716 }
35717
35718
35719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35720   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35721   bool arg2 ;
35722
35723   arg1 = (Dali::Actor *)jarg1;
35724   arg2 = jarg2 ? true : false;
35725   {
35726     try {
35727       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
35728     } catch (std::out_of_range& e) {
35729       {
35730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35731       };
35732     } catch (std::exception& e) {
35733       {
35734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35735       };
35736     } catch (Dali::DaliException e) {
35737       {
35738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35739       };
35740     } catch (...) {
35741       {
35742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35743       };
35744     }
35745   }
35746
35747 }
35748
35749
35750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35751   unsigned int jresult ;
35752   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35753   bool result;
35754
35755   arg1 = (Dali::Actor *)jarg1;
35756   {
35757     try {
35758       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
35759     } catch (std::out_of_range& e) {
35760       {
35761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35762       };
35763     } catch (std::exception& e) {
35764       {
35765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35766       };
35767     } catch (Dali::DaliException e) {
35768       {
35769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35770       };
35771     } catch (...) {
35772       {
35773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35774       };
35775     }
35776   }
35777
35778   jresult = result;
35779   return jresult;
35780 }
35781
35782
35783 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
35784   unsigned int jresult ;
35785   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35786   float *arg2 = 0 ;
35787   float *arg3 = 0 ;
35788   float arg4 ;
35789   float arg5 ;
35790   bool result;
35791
35792   arg1 = (Dali::Actor *)jarg1;
35793   arg2 = (float *)jarg2;
35794   arg3 = (float *)jarg3;
35795   arg4 = (float)jarg4;
35796   arg5 = (float)jarg5;
35797   {
35798     try {
35799       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
35800     } catch (std::out_of_range& e) {
35801       {
35802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35803       };
35804     } catch (std::exception& e) {
35805       {
35806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35807       };
35808     } catch (Dali::DaliException e) {
35809       {
35810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35811       };
35812     } catch (...) {
35813       {
35814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35815       };
35816     }
35817   }
35818
35819   jresult = result;
35820   return jresult;
35821 }
35822
35823
35824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
35825   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35826   bool arg2 ;
35827
35828   arg1 = (Dali::Actor *)jarg1;
35829   arg2 = jarg2 ? true : false;
35830   {
35831     try {
35832       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
35833     } catch (std::out_of_range& e) {
35834       {
35835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35836       };
35837     } catch (std::exception& e) {
35838       {
35839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35840       };
35841     } catch (Dali::DaliException e) {
35842       {
35843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35844       };
35845     } catch (...) {
35846       {
35847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35848       };
35849     }
35850   }
35851
35852 }
35853
35854
35855 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
35856   unsigned int jresult ;
35857   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35858   bool result;
35859
35860   arg1 = (Dali::Actor *)jarg1;
35861   {
35862     try {
35863       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
35864     } catch (std::out_of_range& e) {
35865       {
35866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35867       };
35868     } catch (std::exception& e) {
35869       {
35870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35871       };
35872     } catch (Dali::DaliException e) {
35873       {
35874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35875       };
35876     } catch (...) {
35877       {
35878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35879       };
35880     }
35881   }
35882
35883   jresult = result;
35884   return jresult;
35885 }
35886
35887
35888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
35889   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35890   bool arg2 ;
35891
35892   arg1 = (Dali::Actor *)jarg1;
35893   arg2 = jarg2 ? true : false;
35894   {
35895     try {
35896       (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
35897     } catch (std::out_of_range& e) {
35898       {
35899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35900       };
35901     } catch (std::exception& e) {
35902       {
35903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35904       };
35905     } catch (Dali::DaliException e) {
35906       {
35907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35908       };
35909     } catch (...) {
35910       {
35911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35912       };
35913     }
35914   }
35915
35916 }
35917
35918
35919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
35920   unsigned int jresult ;
35921   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35922   bool result;
35923
35924   arg1 = (Dali::Actor *)jarg1;
35925   {
35926     try {
35927       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
35928     } catch (std::out_of_range& e) {
35929       {
35930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35931       };
35932     } catch (std::exception& e) {
35933       {
35934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35935       };
35936     } catch (Dali::DaliException e) {
35937       {
35938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35939       };
35940     } catch (...) {
35941       {
35942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35943       };
35944     }
35945   }
35946
35947   jresult = result;
35948   return jresult;
35949 }
35950
35951
35952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
35953   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35954   Dali::ResizePolicy::Type arg2 ;
35955   Dali::Dimension::Type arg3 ;
35956
35957   arg1 = (Dali::Actor *)jarg1;
35958   arg2 = (Dali::ResizePolicy::Type)jarg2;
35959   arg3 = (Dali::Dimension::Type)jarg3;
35960   {
35961     try {
35962       (arg1)->SetResizePolicy(arg2,arg3);
35963     } catch (std::out_of_range& e) {
35964       {
35965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35966       };
35967     } catch (std::exception& e) {
35968       {
35969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35970       };
35971     } catch (Dali::DaliException e) {
35972       {
35973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35974       };
35975     } catch (...) {
35976       {
35977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35978       };
35979     }
35980   }
35981
35982 }
35983
35984
35985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
35986   int jresult ;
35987   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35988   Dali::Dimension::Type arg2 ;
35989   Dali::ResizePolicy::Type result;
35990
35991   arg1 = (Dali::Actor *)jarg1;
35992   arg2 = (Dali::Dimension::Type)jarg2;
35993   {
35994     try {
35995       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
35996     } catch (std::out_of_range& e) {
35997       {
35998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35999       };
36000     } catch (std::exception& e) {
36001       {
36002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36003       };
36004     } catch (Dali::DaliException e) {
36005       {
36006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36007       };
36008     } catch (...) {
36009       {
36010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36011       };
36012     }
36013   }
36014
36015   jresult = (int)result;
36016   return jresult;
36017 }
36018
36019
36020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36021   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36022   Dali::SizeScalePolicy::Type arg2 ;
36023
36024   arg1 = (Dali::Actor *)jarg1;
36025   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36026   {
36027     try {
36028       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
36029     } catch (std::out_of_range& e) {
36030       {
36031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36032       };
36033     } catch (std::exception& e) {
36034       {
36035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36036       };
36037     } catch (Dali::DaliException e) {
36038       {
36039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36040       };
36041     } catch (...) {
36042       {
36043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36044       };
36045     }
36046   }
36047
36048 }
36049
36050
36051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36052   int jresult ;
36053   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36054   Dali::SizeScalePolicy::Type result;
36055
36056   arg1 = (Dali::Actor *)jarg1;
36057   {
36058     try {
36059       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
36060     } catch (std::out_of_range& e) {
36061       {
36062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36063       };
36064     } catch (std::exception& e) {
36065       {
36066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36067       };
36068     } catch (Dali::DaliException e) {
36069       {
36070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36071       };
36072     } catch (...) {
36073       {
36074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36075       };
36076     }
36077   }
36078
36079   jresult = (int)result;
36080   return jresult;
36081 }
36082
36083
36084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36085   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36086   Dali::Vector3 *arg2 = 0 ;
36087
36088   arg1 = (Dali::Actor *)jarg1;
36089   arg2 = (Dali::Vector3 *)jarg2;
36090   if (!arg2) {
36091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36092     return ;
36093   }
36094   {
36095     try {
36096       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
36097     } catch (std::out_of_range& e) {
36098       {
36099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36100       };
36101     } catch (std::exception& e) {
36102       {
36103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36104       };
36105     } catch (Dali::DaliException e) {
36106       {
36107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36108       };
36109     } catch (...) {
36110       {
36111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36112       };
36113     }
36114   }
36115
36116 }
36117
36118
36119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36120   void * jresult ;
36121   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36122   Dali::Vector3 result;
36123
36124   arg1 = (Dali::Actor *)jarg1;
36125   {
36126     try {
36127       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
36128     } catch (std::out_of_range& e) {
36129       {
36130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36131       };
36132     } catch (std::exception& e) {
36133       {
36134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36135       };
36136     } catch (Dali::DaliException e) {
36137       {
36138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36139       };
36140     } catch (...) {
36141       {
36142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36143       };
36144     }
36145   }
36146
36147   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36148   return jresult;
36149 }
36150
36151
36152 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36153   float jresult ;
36154   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36155   float arg2 ;
36156   float result;
36157
36158   arg1 = (Dali::Actor *)jarg1;
36159   arg2 = (float)jarg2;
36160   {
36161     try {
36162       result = (float)(arg1)->GetHeightForWidth(arg2);
36163     } catch (std::out_of_range& e) {
36164       {
36165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36166       };
36167     } catch (std::exception& e) {
36168       {
36169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36170       };
36171     } catch (Dali::DaliException e) {
36172       {
36173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36174       };
36175     } catch (...) {
36176       {
36177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36178       };
36179     }
36180   }
36181
36182   jresult = result;
36183   return jresult;
36184 }
36185
36186
36187 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36188   float jresult ;
36189   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36190   float arg2 ;
36191   float result;
36192
36193   arg1 = (Dali::Actor *)jarg1;
36194   arg2 = (float)jarg2;
36195   {
36196     try {
36197       result = (float)(arg1)->GetWidthForHeight(arg2);
36198     } catch (std::out_of_range& e) {
36199       {
36200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36201       };
36202     } catch (std::exception& e) {
36203       {
36204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36205       };
36206     } catch (Dali::DaliException e) {
36207       {
36208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36209       };
36210     } catch (...) {
36211       {
36212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36213       };
36214     }
36215   }
36216
36217   jresult = result;
36218   return jresult;
36219 }
36220
36221
36222 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36223   float jresult ;
36224   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36225   Dali::Dimension::Type arg2 ;
36226   float result;
36227
36228   arg1 = (Dali::Actor *)jarg1;
36229   arg2 = (Dali::Dimension::Type)jarg2;
36230   {
36231     try {
36232       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36233     } catch (std::out_of_range& e) {
36234       {
36235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36236       };
36237     } catch (std::exception& e) {
36238       {
36239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36240       };
36241     } catch (Dali::DaliException e) {
36242       {
36243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36244       };
36245     } catch (...) {
36246       {
36247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36248       };
36249     }
36250   }
36251
36252   jresult = result;
36253   return jresult;
36254 }
36255
36256
36257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36258   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36259   Dali::Padding *arg2 = 0 ;
36260
36261   arg1 = (Dali::Actor *)jarg1;
36262   arg2 = (Dali::Padding *)jarg2;
36263   if (!arg2) {
36264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36265     return ;
36266   }
36267   {
36268     try {
36269       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
36270     } catch (std::out_of_range& e) {
36271       {
36272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36273       };
36274     } catch (std::exception& e) {
36275       {
36276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36277       };
36278     } catch (Dali::DaliException e) {
36279       {
36280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36281       };
36282     } catch (...) {
36283       {
36284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36285       };
36286     }
36287   }
36288
36289 }
36290
36291
36292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36293   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36294   Dali::Padding *arg2 = 0 ;
36295
36296   arg1 = (Dali::Actor *)jarg1;
36297   arg2 = (Dali::Padding *)jarg2;
36298   if (!arg2) {
36299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36300     return ;
36301   }
36302   {
36303     try {
36304       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
36305     } catch (std::out_of_range& e) {
36306       {
36307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36308       };
36309     } catch (std::exception& e) {
36310       {
36311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36312       };
36313     } catch (Dali::DaliException e) {
36314       {
36315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36316       };
36317     } catch (...) {
36318       {
36319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36320       };
36321     }
36322   }
36323
36324 }
36325
36326
36327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36328   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36329   Dali::Vector2 *arg2 = 0 ;
36330
36331   arg1 = (Dali::Actor *)jarg1;
36332   arg2 = (Dali::Vector2 *)jarg2;
36333   if (!arg2) {
36334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36335     return ;
36336   }
36337   {
36338     try {
36339       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36340     } catch (std::out_of_range& e) {
36341       {
36342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36343       };
36344     } catch (std::exception& e) {
36345       {
36346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36347       };
36348     } catch (Dali::DaliException e) {
36349       {
36350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36351       };
36352     } catch (...) {
36353       {
36354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36355       };
36356     }
36357   }
36358
36359 }
36360
36361
36362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36363   void * jresult ;
36364   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36365   Dali::Vector2 result;
36366
36367   arg1 = (Dali::Actor *)jarg1;
36368   {
36369     try {
36370       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
36371     } catch (std::out_of_range& e) {
36372       {
36373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36374       };
36375     } catch (std::exception& e) {
36376       {
36377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36378       };
36379     } catch (Dali::DaliException e) {
36380       {
36381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36382       };
36383     } catch (...) {
36384       {
36385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36386       };
36387     }
36388   }
36389
36390   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36391   return jresult;
36392 }
36393
36394
36395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36396   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36397   Dali::Vector2 *arg2 = 0 ;
36398
36399   arg1 = (Dali::Actor *)jarg1;
36400   arg2 = (Dali::Vector2 *)jarg2;
36401   if (!arg2) {
36402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36403     return ;
36404   }
36405   {
36406     try {
36407       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36408     } catch (std::out_of_range& e) {
36409       {
36410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36411       };
36412     } catch (std::exception& e) {
36413       {
36414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36415       };
36416     } catch (Dali::DaliException e) {
36417       {
36418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36419       };
36420     } catch (...) {
36421       {
36422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36423       };
36424     }
36425   }
36426
36427 }
36428
36429
36430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36431   void * jresult ;
36432   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36433   Dali::Vector2 result;
36434
36435   arg1 = (Dali::Actor *)jarg1;
36436   {
36437     try {
36438       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
36439     } catch (std::out_of_range& e) {
36440       {
36441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36442       };
36443     } catch (std::exception& e) {
36444       {
36445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36446       };
36447     } catch (Dali::DaliException e) {
36448       {
36449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36450       };
36451     } catch (...) {
36452       {
36453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36454       };
36455     }
36456   }
36457
36458   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36459   return jresult;
36460 }
36461
36462
36463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36464   int jresult ;
36465   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36466   int result;
36467
36468   arg1 = (Dali::Actor *)jarg1;
36469   {
36470     try {
36471       result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
36472       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36473     } catch (std::out_of_range& e) {
36474       {
36475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36476       };
36477     } catch (std::exception& e) {
36478       {
36479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36480       };
36481     } catch (Dali::DaliException e) {
36482       {
36483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36484       };
36485     } catch (...) {
36486       {
36487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36488       };
36489     }
36490   }
36491
36492   jresult = result;
36493   return jresult;
36494 }
36495
36496
36497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36498   unsigned int jresult ;
36499   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36500   Dali::Renderer *arg2 = 0 ;
36501   unsigned int result;
36502
36503   arg1 = (Dali::Actor *)jarg1;
36504   arg2 = (Dali::Renderer *)jarg2;
36505   if (!arg2) {
36506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36507     return 0;
36508   }
36509   {
36510     try {
36511       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36512     } catch (std::out_of_range& e) {
36513       {
36514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36515       };
36516     } catch (std::exception& e) {
36517       {
36518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36519       };
36520     } catch (Dali::DaliException e) {
36521       {
36522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36523       };
36524     } catch (...) {
36525       {
36526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36527       };
36528     }
36529   }
36530
36531   jresult = result;
36532   return jresult;
36533 }
36534
36535
36536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36537   unsigned int jresult ;
36538   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36539   unsigned int result;
36540
36541   arg1 = (Dali::Actor *)jarg1;
36542   {
36543     try {
36544       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36545     } catch (std::out_of_range& e) {
36546       {
36547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36548       };
36549     } catch (std::exception& e) {
36550       {
36551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36552       };
36553     } catch (Dali::DaliException e) {
36554       {
36555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36556       };
36557     } catch (...) {
36558       {
36559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36560       };
36561     }
36562   }
36563
36564   jresult = result;
36565   return jresult;
36566 }
36567
36568
36569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36570   void * jresult ;
36571   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36572   unsigned int arg2 ;
36573   Dali::Renderer result;
36574
36575   arg1 = (Dali::Actor *)jarg1;
36576   arg2 = (unsigned int)jarg2;
36577   {
36578     try {
36579       result = (arg1)->GetRendererAt(arg2);
36580     } catch (std::out_of_range& e) {
36581       {
36582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36583       };
36584     } catch (std::exception& e) {
36585       {
36586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36587       };
36588     } catch (Dali::DaliException e) {
36589       {
36590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36591       };
36592     } catch (...) {
36593       {
36594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36595       };
36596     }
36597   }
36598
36599   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36600   return jresult;
36601 }
36602
36603
36604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36605   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36606   Dali::Renderer *arg2 = 0 ;
36607
36608   arg1 = (Dali::Actor *)jarg1;
36609   arg2 = (Dali::Renderer *)jarg2;
36610   if (!arg2) {
36611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36612     return ;
36613   }
36614   {
36615     try {
36616       (arg1)->RemoveRenderer(*arg2);
36617     } catch (std::out_of_range& e) {
36618       {
36619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36620       };
36621     } catch (std::exception& e) {
36622       {
36623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36624       };
36625     } catch (Dali::DaliException e) {
36626       {
36627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36628       };
36629     } catch (...) {
36630       {
36631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36632       };
36633     }
36634   }
36635
36636 }
36637
36638
36639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36640   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36641   unsigned int arg2 ;
36642
36643   arg1 = (Dali::Actor *)jarg1;
36644   arg2 = (unsigned int)jarg2;
36645   {
36646     try {
36647       (arg1)->RemoveRenderer(arg2);
36648     } catch (std::out_of_range& e) {
36649       {
36650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36651       };
36652     } catch (std::exception& e) {
36653       {
36654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36655       };
36656     } catch (Dali::DaliException e) {
36657       {
36658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36659       };
36660     } catch (...) {
36661       {
36662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36663       };
36664     }
36665   }
36666
36667 }
36668
36669
36670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36671   void * jresult ;
36672   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36673   Dali::Actor::TouchDataSignalType *result = 0 ;
36674
36675   arg1 = (Dali::Actor *)jarg1;
36676   {
36677     try {
36678       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36679     } catch (std::out_of_range& e) {
36680       {
36681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36682       };
36683     } catch (std::exception& e) {
36684       {
36685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36686       };
36687     } catch (Dali::DaliException e) {
36688       {
36689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36690       };
36691     } catch (...) {
36692       {
36693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36694       };
36695     }
36696   }
36697
36698   jresult = (void *)result;
36699   return jresult;
36700 }
36701
36702
36703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36704   void * jresult ;
36705   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36706   Dali::Actor::HoverSignalType *result = 0 ;
36707
36708   arg1 = (Dali::Actor *)jarg1;
36709   {
36710     try {
36711       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36712     } catch (std::out_of_range& e) {
36713       {
36714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36715       };
36716     } catch (std::exception& e) {
36717       {
36718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36719       };
36720     } catch (Dali::DaliException e) {
36721       {
36722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36723       };
36724     } catch (...) {
36725       {
36726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36727       };
36728     }
36729   }
36730
36731   jresult = (void *)result;
36732   return jresult;
36733 }
36734
36735
36736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
36737   void * jresult ;
36738   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36739   Dali::Actor::WheelEventSignalType *result = 0 ;
36740
36741   arg1 = (Dali::Actor *)jarg1;
36742   {
36743     try {
36744       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
36745     } catch (std::out_of_range& e) {
36746       {
36747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36748       };
36749     } catch (std::exception& e) {
36750       {
36751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36752       };
36753     } catch (Dali::DaliException e) {
36754       {
36755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36756       };
36757     } catch (...) {
36758       {
36759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36760       };
36761     }
36762   }
36763
36764   jresult = (void *)result;
36765   return jresult;
36766 }
36767
36768
36769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnSceneSignal(void * jarg1) {
36770   void * jresult ;
36771   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36772   Dali::Actor::OnSceneSignalType *result = 0 ;
36773
36774   arg1 = (Dali::Actor *)jarg1;
36775   {
36776     try {
36777       result = (Dali::Actor::OnSceneSignalType *) &(arg1)->OnSceneSignal();
36778     } catch (std::out_of_range& e) {
36779       {
36780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36781       };
36782     } catch (std::exception& e) {
36783       {
36784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36785       };
36786     } catch (Dali::DaliException e) {
36787       {
36788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36789       };
36790     } catch (...) {
36791       {
36792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36793       };
36794     }
36795   }
36796
36797   jresult = (void *)result;
36798   return jresult;
36799 }
36800
36801
36802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffSceneSignal(void * jarg1) {
36803   void * jresult ;
36804   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36805   Dali::Actor::OffSceneSignalType *result = 0 ;
36806
36807   arg1 = (Dali::Actor *)jarg1;
36808   {
36809     try {
36810       result = (Dali::Actor::OffSceneSignalType *) &(arg1)->OffSceneSignal();
36811     } catch (std::out_of_range& e) {
36812       {
36813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36814       };
36815     } catch (std::exception& e) {
36816       {
36817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36818       };
36819     } catch (Dali::DaliException e) {
36820       {
36821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36822       };
36823     } catch (...) {
36824       {
36825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36826       };
36827     }
36828   }
36829
36830   jresult = (void *)result;
36831   return jresult;
36832 }
36833
36834
36835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
36836   void * jresult ;
36837   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36838   Dali::Actor::OnRelayoutSignalType *result = 0 ;
36839
36840   arg1 = (Dali::Actor *)jarg1;
36841   {
36842     try {
36843       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
36844     } catch (std::out_of_range& e) {
36845       {
36846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36847       };
36848     } catch (std::exception& e) {
36849       {
36850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36851       };
36852     } catch (Dali::DaliException e) {
36853       {
36854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36855       };
36856     } catch (...) {
36857       {
36858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36859       };
36860     }
36861   }
36862
36863   jresult = (void *)result;
36864   return jresult;
36865 }
36866
36867
36868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
36869   Dali::Actor *arg1 = 0 ;
36870
36871   arg1 = (Dali::Actor *)jarg1;
36872   if (!arg1) {
36873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36874     return ;
36875   }
36876   {
36877     try {
36878       Dali::UnparentAndReset(*arg1);
36879     } catch (std::out_of_range& e) {
36880       {
36881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36882       };
36883     } catch (std::exception& e) {
36884       {
36885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36886       };
36887     } catch (Dali::DaliException e) {
36888       {
36889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36890       };
36891     } catch (...) {
36892       {
36893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36894       };
36895     }
36896   }
36897
36898 }
36899
36900
36901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
36902   int jresult ;
36903   int result;
36904
36905   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
36906   jresult = (int)result;
36907   return jresult;
36908 }
36909
36910
36911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
36912   int jresult ;
36913   int result;
36914
36915   result = (int)Dali::Layer::Property::CLIPPING_BOX;
36916   jresult = (int)result;
36917   return jresult;
36918 }
36919
36920
36921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
36922   int jresult ;
36923   int result;
36924
36925   result = (int)Dali::Layer::Property::BEHAVIOR;
36926   jresult = (int)result;
36927   return jresult;
36928 }
36929
36930
36931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
36932   void * jresult ;
36933   Dali::Layer::Property *result = 0 ;
36934
36935   {
36936     try {
36937       result = (Dali::Layer::Property *)new Dali::Layer::Property();
36938     } catch (std::out_of_range& e) {
36939       {
36940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36941       };
36942     } catch (std::exception& e) {
36943       {
36944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36945       };
36946     } catch (Dali::DaliException e) {
36947       {
36948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36949       };
36950     } catch (...) {
36951       {
36952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36953       };
36954     }
36955   }
36956
36957   jresult = (void *)result;
36958   return jresult;
36959 }
36960
36961
36962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
36963   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
36964
36965   arg1 = (Dali::Layer::Property *)jarg1;
36966   {
36967     try {
36968       delete arg1;
36969     } catch (std::out_of_range& e) {
36970       {
36971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36972       };
36973     } catch (std::exception& e) {
36974       {
36975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36976       };
36977     } catch (Dali::DaliException e) {
36978       {
36979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36980       };
36981     } catch (...) {
36982       {
36983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36984       };
36985     }
36986   }
36987
36988 }
36989
36990
36991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
36992   void * jresult ;
36993   Dali::Layer *result = 0 ;
36994
36995   {
36996     try {
36997       result = (Dali::Layer *)new Dali::Layer();
36998     } catch (std::out_of_range& e) {
36999       {
37000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37001       };
37002     } catch (std::exception& e) {
37003       {
37004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37005       };
37006     } catch (Dali::DaliException e) {
37007       {
37008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37009       };
37010     } catch (...) {
37011       {
37012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37013       };
37014     }
37015   }
37016
37017   jresult = (void *)result;
37018   return jresult;
37019 }
37020
37021
37022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37023   void * jresult ;
37024   Dali::Layer result;
37025
37026   {
37027     try {
37028       result = Dali::Layer::New();
37029     } catch (std::out_of_range& e) {
37030       {
37031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37032       };
37033     } catch (std::exception& e) {
37034       {
37035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37036       };
37037     } catch (Dali::DaliException e) {
37038       {
37039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37040       };
37041     } catch (...) {
37042       {
37043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37044       };
37045     }
37046   }
37047
37048   jresult = new Dali::Layer((const Dali::Layer &)result);
37049   return jresult;
37050 }
37051
37052
37053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37054   void * jresult ;
37055   Dali::BaseHandle arg1 ;
37056   Dali::BaseHandle *argp1 ;
37057   Dali::Layer result;
37058
37059   argp1 = (Dali::BaseHandle *)jarg1;
37060   if (!argp1) {
37061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37062     return 0;
37063   }
37064   arg1 = *argp1;
37065   {
37066     try {
37067       result = Dali::Layer::DownCast(arg1);
37068     } catch (std::out_of_range& e) {
37069       {
37070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37071       };
37072     } catch (std::exception& e) {
37073       {
37074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37075       };
37076     } catch (Dali::DaliException e) {
37077       {
37078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37079       };
37080     } catch (...) {
37081       {
37082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37083       };
37084     }
37085   }
37086
37087   jresult = new Dali::Layer((const Dali::Layer &)result);
37088   return jresult;
37089 }
37090
37091
37092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37093   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37094
37095   arg1 = (Dali::Layer *)jarg1;
37096   {
37097     try {
37098       delete arg1;
37099     } catch (std::out_of_range& e) {
37100       {
37101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37102       };
37103     } catch (std::exception& e) {
37104       {
37105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37106       };
37107     } catch (Dali::DaliException e) {
37108       {
37109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37110       };
37111     } catch (...) {
37112       {
37113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37114       };
37115     }
37116   }
37117
37118 }
37119
37120
37121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37122   void * jresult ;
37123   Dali::Layer *arg1 = 0 ;
37124   Dali::Layer *result = 0 ;
37125
37126   arg1 = (Dali::Layer *)jarg1;
37127   if (!arg1) {
37128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37129     return 0;
37130   }
37131   {
37132     try {
37133       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37134     } catch (std::out_of_range& e) {
37135       {
37136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37137       };
37138     } catch (std::exception& e) {
37139       {
37140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37141       };
37142     } catch (Dali::DaliException e) {
37143       {
37144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37145       };
37146     } catch (...) {
37147       {
37148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37149       };
37150     }
37151   }
37152
37153   jresult = (void *)result;
37154   return jresult;
37155 }
37156
37157
37158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37159   void * jresult ;
37160   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37161   Dali::Layer *arg2 = 0 ;
37162   Dali::Layer *result = 0 ;
37163
37164   arg1 = (Dali::Layer *)jarg1;
37165   arg2 = (Dali::Layer *)jarg2;
37166   if (!arg2) {
37167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37168     return 0;
37169   }
37170   {
37171     try {
37172       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37173     } catch (std::out_of_range& e) {
37174       {
37175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37176       };
37177     } catch (std::exception& e) {
37178       {
37179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37180       };
37181     } catch (Dali::DaliException e) {
37182       {
37183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37184       };
37185     } catch (...) {
37186       {
37187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37188       };
37189     }
37190   }
37191
37192   jresult = (void *)result;
37193   return jresult;
37194 }
37195
37196
37197 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37198   unsigned int jresult ;
37199   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37200   unsigned int result;
37201
37202   arg1 = (Dali::Layer *)jarg1;
37203   {
37204     try {
37205       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
37206     } catch (std::out_of_range& e) {
37207       {
37208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37209       };
37210     } catch (std::exception& e) {
37211       {
37212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37213       };
37214     } catch (Dali::DaliException e) {
37215       {
37216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37217       };
37218     } catch (...) {
37219       {
37220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37221       };
37222     }
37223   }
37224
37225   jresult = result;
37226   return jresult;
37227 }
37228
37229
37230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37231   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37232
37233   arg1 = (Dali::Layer *)jarg1;
37234   {
37235     try {
37236       (arg1)->Raise();
37237     } catch (std::out_of_range& e) {
37238       {
37239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37240       };
37241     } catch (std::exception& e) {
37242       {
37243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37244       };
37245     } catch (Dali::DaliException e) {
37246       {
37247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37248       };
37249     } catch (...) {
37250       {
37251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37252       };
37253     }
37254   }
37255
37256 }
37257
37258
37259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37260   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37261
37262   arg1 = (Dali::Layer *)jarg1;
37263   {
37264     try {
37265       (arg1)->Lower();
37266     } catch (std::out_of_range& e) {
37267       {
37268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37269       };
37270     } catch (std::exception& e) {
37271       {
37272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37273       };
37274     } catch (Dali::DaliException e) {
37275       {
37276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37277       };
37278     } catch (...) {
37279       {
37280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37281       };
37282     }
37283   }
37284
37285 }
37286
37287
37288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37289   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37290   Dali::Layer arg2 ;
37291   Dali::Layer *argp2 ;
37292
37293   arg1 = (Dali::Layer *)jarg1;
37294   argp2 = (Dali::Layer *)jarg2;
37295   if (!argp2) {
37296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37297     return ;
37298   }
37299   arg2 = *argp2;
37300   {
37301     try {
37302       (arg1)->RaiseAbove(arg2);
37303     } catch (std::out_of_range& e) {
37304       {
37305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37306       };
37307     } catch (std::exception& e) {
37308       {
37309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37310       };
37311     } catch (Dali::DaliException e) {
37312       {
37313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37314       };
37315     } catch (...) {
37316       {
37317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37318       };
37319     }
37320   }
37321
37322 }
37323
37324
37325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37326   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37327   Dali::Layer arg2 ;
37328   Dali::Layer *argp2 ;
37329
37330   arg1 = (Dali::Layer *)jarg1;
37331   argp2 = (Dali::Layer *)jarg2;
37332   if (!argp2) {
37333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37334     return ;
37335   }
37336   arg2 = *argp2;
37337   {
37338     try {
37339       (arg1)->LowerBelow(arg2);
37340     } catch (std::out_of_range& e) {
37341       {
37342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37343       };
37344     } catch (std::exception& e) {
37345       {
37346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37347       };
37348     } catch (Dali::DaliException e) {
37349       {
37350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37351       };
37352     } catch (...) {
37353       {
37354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37355       };
37356     }
37357   }
37358
37359 }
37360
37361
37362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37363   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37364
37365   arg1 = (Dali::Layer *)jarg1;
37366   {
37367     try {
37368       (arg1)->RaiseToTop();
37369     } catch (std::out_of_range& e) {
37370       {
37371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37372       };
37373     } catch (std::exception& e) {
37374       {
37375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37376       };
37377     } catch (Dali::DaliException e) {
37378       {
37379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37380       };
37381     } catch (...) {
37382       {
37383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37384       };
37385     }
37386   }
37387
37388 }
37389
37390
37391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37392   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37393
37394   arg1 = (Dali::Layer *)jarg1;
37395   {
37396     try {
37397       (arg1)->LowerToBottom();
37398     } catch (std::out_of_range& e) {
37399       {
37400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37401       };
37402     } catch (std::exception& e) {
37403       {
37404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37405       };
37406     } catch (Dali::DaliException e) {
37407       {
37408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37409       };
37410     } catch (...) {
37411       {
37412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37413       };
37414     }
37415   }
37416
37417 }
37418
37419
37420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37421   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37422   Dali::Layer arg2 ;
37423   Dali::Layer *argp2 ;
37424
37425   arg1 = (Dali::Layer *)jarg1;
37426   argp2 = (Dali::Layer *)jarg2;
37427   if (!argp2) {
37428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37429     return ;
37430   }
37431   arg2 = *argp2;
37432   {
37433     try {
37434       (arg1)->MoveAbove(arg2);
37435     } catch (std::out_of_range& e) {
37436       {
37437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37438       };
37439     } catch (std::exception& e) {
37440       {
37441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37442       };
37443     } catch (Dali::DaliException e) {
37444       {
37445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37446       };
37447     } catch (...) {
37448       {
37449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37450       };
37451     }
37452   }
37453
37454 }
37455
37456
37457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37458   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37459   Dali::Layer arg2 ;
37460   Dali::Layer *argp2 ;
37461
37462   arg1 = (Dali::Layer *)jarg1;
37463   argp2 = (Dali::Layer *)jarg2;
37464   if (!argp2) {
37465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37466     return ;
37467   }
37468   arg2 = *argp2;
37469   {
37470     try {
37471       (arg1)->MoveBelow(arg2);
37472     } catch (std::out_of_range& e) {
37473       {
37474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37475       };
37476     } catch (std::exception& e) {
37477       {
37478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37479       };
37480     } catch (Dali::DaliException e) {
37481       {
37482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37483       };
37484     } catch (...) {
37485       {
37486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37487       };
37488     }
37489   }
37490
37491 }
37492
37493
37494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37495   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37496   Dali::Layer::Behavior arg2 ;
37497
37498   arg1 = (Dali::Layer *)jarg1;
37499   arg2 = (Dali::Layer::Behavior)jarg2;
37500   {
37501     try {
37502       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
37503     } catch (std::out_of_range& e) {
37504       {
37505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37506       };
37507     } catch (std::exception& e) {
37508       {
37509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37510       };
37511     } catch (Dali::DaliException e) {
37512       {
37513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37514       };
37515     } catch (...) {
37516       {
37517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37518       };
37519     }
37520   }
37521
37522 }
37523
37524
37525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37526   int jresult ;
37527   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37528   Dali::Layer::Behavior result;
37529
37530   arg1 = (Dali::Layer *)jarg1;
37531   {
37532     try {
37533       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
37534     } catch (std::out_of_range& e) {
37535       {
37536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37537       };
37538     } catch (std::exception& e) {
37539       {
37540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37541       };
37542     } catch (Dali::DaliException e) {
37543       {
37544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37545       };
37546     } catch (...) {
37547       {
37548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37549       };
37550     }
37551   }
37552
37553   jresult = (int)result;
37554   return jresult;
37555 }
37556
37557
37558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37559   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37560   bool arg2 ;
37561
37562   arg1 = (Dali::Layer *)jarg1;
37563   arg2 = jarg2 ? true : false;
37564   {
37565     try {
37566       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
37567     } catch (std::out_of_range& e) {
37568       {
37569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37570       };
37571     } catch (std::exception& e) {
37572       {
37573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37574       };
37575     } catch (Dali::DaliException e) {
37576       {
37577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37578       };
37579     } catch (...) {
37580       {
37581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37582       };
37583     }
37584   }
37585
37586 }
37587
37588
37589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37590   unsigned int jresult ;
37591   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37592   bool result;
37593
37594   arg1 = (Dali::Layer *)jarg1;
37595   {
37596     try {
37597       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
37598     } catch (std::out_of_range& e) {
37599       {
37600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37601       };
37602     } catch (std::exception& e) {
37603       {
37604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37605       };
37606     } catch (Dali::DaliException e) {
37607       {
37608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37609       };
37610     } catch (...) {
37611       {
37612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37613       };
37614     }
37615   }
37616
37617   jresult = result;
37618   return jresult;
37619 }
37620
37621
37622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37623   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37624   int arg2 ;
37625   int arg3 ;
37626   int arg4 ;
37627   int arg5 ;
37628
37629   arg1 = (Dali::Layer *)jarg1;
37630   arg2 = (int)jarg2;
37631   arg3 = (int)jarg3;
37632   arg4 = (int)jarg4;
37633   arg5 = (int)jarg5;
37634   {
37635     try {
37636       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
37637     } catch (std::out_of_range& e) {
37638       {
37639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37640       };
37641     } catch (std::exception& e) {
37642       {
37643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37644       };
37645     } catch (Dali::DaliException e) {
37646       {
37647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37648       };
37649     } catch (...) {
37650       {
37651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37652       };
37653     }
37654   }
37655
37656 }
37657
37658
37659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37660   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37661   Dali::ClippingBox arg2 ;
37662   Dali::ClippingBox *argp2 ;
37663
37664   arg1 = (Dali::Layer *)jarg1;
37665   argp2 = (Dali::ClippingBox *)jarg2;
37666   if (!argp2) {
37667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37668     return ;
37669   }
37670   arg2 = *argp2;
37671   {
37672     try {
37673       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
37674     } catch (std::out_of_range& e) {
37675       {
37676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37677       };
37678     } catch (std::exception& e) {
37679       {
37680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37681       };
37682     } catch (Dali::DaliException e) {
37683       {
37684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37685       };
37686     } catch (...) {
37687       {
37688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37689       };
37690     }
37691   }
37692
37693 }
37694
37695
37696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37697   void * jresult ;
37698   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37699   Dali::ClippingBox result;
37700
37701   arg1 = (Dali::Layer *)jarg1;
37702   {
37703     try {
37704       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
37705     } catch (std::out_of_range& e) {
37706       {
37707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37708       };
37709     } catch (std::exception& e) {
37710       {
37711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37712       };
37713     } catch (Dali::DaliException e) {
37714       {
37715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37716       };
37717     } catch (...) {
37718       {
37719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37720       };
37721     }
37722   }
37723
37724   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37725   return jresult;
37726 }
37727
37728
37729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
37730   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37731   bool arg2 ;
37732
37733   arg1 = (Dali::Layer *)jarg1;
37734   arg2 = jarg2 ? true : false;
37735   {
37736     try {
37737       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
37738     } catch (std::out_of_range& e) {
37739       {
37740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37741       };
37742     } catch (std::exception& e) {
37743       {
37744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37745       };
37746     } catch (Dali::DaliException e) {
37747       {
37748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37749       };
37750     } catch (...) {
37751       {
37752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37753       };
37754     }
37755   }
37756
37757 }
37758
37759
37760 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
37761   unsigned int jresult ;
37762   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37763   bool result;
37764
37765   arg1 = (Dali::Layer *)jarg1;
37766   {
37767     try {
37768       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
37769     } catch (std::out_of_range& e) {
37770       {
37771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37772       };
37773     } catch (std::exception& e) {
37774       {
37775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37776       };
37777     } catch (Dali::DaliException e) {
37778       {
37779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37780       };
37781     } catch (...) {
37782       {
37783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37784       };
37785     }
37786   }
37787
37788   jresult = result;
37789   return jresult;
37790 }
37791
37792
37793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
37794   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37795   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
37796
37797   arg1 = (Dali::Layer *)jarg1;
37798   arg2 = (Dali::Layer::SortFunctionType)jarg2;
37799   {
37800     try {
37801       (arg1)->SetSortFunction(arg2);
37802     } catch (std::out_of_range& e) {
37803       {
37804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37805       };
37806     } catch (std::exception& e) {
37807       {
37808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37809       };
37810     } catch (Dali::DaliException e) {
37811       {
37812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37813       };
37814     } catch (...) {
37815       {
37816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37817       };
37818     }
37819   }
37820
37821 }
37822
37823
37824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
37825   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37826   bool arg2 ;
37827
37828   arg1 = (Dali::Layer *)jarg1;
37829   arg2 = jarg2 ? true : false;
37830   {
37831     try {
37832       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
37833     } catch (std::out_of_range& e) {
37834       {
37835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37836       };
37837     } catch (std::exception& e) {
37838       {
37839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37840       };
37841     } catch (Dali::DaliException e) {
37842       {
37843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37844       };
37845     } catch (...) {
37846       {
37847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37848       };
37849     }
37850   }
37851
37852 }
37853
37854
37855 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
37856   unsigned int jresult ;
37857   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37858   bool result;
37859
37860   arg1 = (Dali::Layer *)jarg1;
37861   {
37862     try {
37863       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
37864     } catch (std::out_of_range& e) {
37865       {
37866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37867       };
37868     } catch (std::exception& e) {
37869       {
37870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37871       };
37872     } catch (Dali::DaliException e) {
37873       {
37874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37875       };
37876     } catch (...) {
37877       {
37878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37879       };
37880     }
37881   }
37882
37883   jresult = result;
37884   return jresult;
37885 }
37886
37887
37888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
37889   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37890   bool arg2 ;
37891
37892   arg1 = (Dali::Layer *)jarg1;
37893   arg2 = jarg2 ? true : false;
37894   {
37895     try {
37896       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
37897     } catch (std::out_of_range& e) {
37898       {
37899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37900       };
37901     } catch (std::exception& e) {
37902       {
37903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37904       };
37905     } catch (Dali::DaliException e) {
37906       {
37907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37908       };
37909     } catch (...) {
37910       {
37911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37912       };
37913     }
37914   }
37915
37916 }
37917
37918
37919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
37920   unsigned int jresult ;
37921   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37922   bool result;
37923
37924   arg1 = (Dali::Layer *)jarg1;
37925   {
37926     try {
37927       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
37928     } catch (std::out_of_range& e) {
37929       {
37930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37931       };
37932     } catch (std::exception& e) {
37933       {
37934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37935       };
37936     } catch (Dali::DaliException e) {
37937       {
37938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37939       };
37940     } catch (...) {
37941       {
37942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37943       };
37944     }
37945   }
37946
37947   jresult = result;
37948   return jresult;
37949 }
37950
37951
37952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
37953   void * jresult ;
37954   Dali::Stage result;
37955
37956   {
37957     try {
37958       result = Dali::Stage::GetCurrent();
37959     } catch (std::out_of_range& e) {
37960       {
37961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37962       };
37963     } catch (std::exception& e) {
37964       {
37965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37966       };
37967     } catch (Dali::DaliException e) {
37968       {
37969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37970       };
37971     } catch (...) {
37972       {
37973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37974       };
37975     }
37976   }
37977
37978   jresult = new Dali::Stage((const Dali::Stage &)result);
37979   return jresult;
37980 }
37981
37982
37983 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
37984   unsigned int jresult ;
37985   bool result;
37986
37987   {
37988     try {
37989       result = (bool)Dali::Stage::IsInstalled();
37990     } catch (std::out_of_range& e) {
37991       {
37992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37993       };
37994     } catch (std::exception& e) {
37995       {
37996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37997       };
37998     } catch (Dali::DaliException e) {
37999       {
38000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38001       };
38002     } catch (...) {
38003       {
38004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38005       };
38006     }
38007   }
38008
38009   jresult = result;
38010   return jresult;
38011 }
38012
38013
38014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38015   void * jresult ;
38016   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38017   Dali::Vector2 result;
38018
38019   arg1 = (Dali::Stage *)jarg1;
38020   {
38021     try {
38022       result = ((Dali::Stage const *)arg1)->GetDpi();
38023     } catch (std::out_of_range& e) {
38024       {
38025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38026       };
38027     } catch (std::exception& e) {
38028       {
38029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38030       };
38031     } catch (Dali::DaliException e) {
38032       {
38033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38034       };
38035     } catch (...) {
38036       {
38037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38038       };
38039     }
38040   }
38041
38042   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38043   return jresult;
38044 }
38045
38046
38047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38048   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38049   float arg2 ;
38050
38051   arg1 = (Dali::Stage *)jarg1;
38052   arg2 = (float)jarg2;
38053   {
38054     try {
38055       (arg1)->KeepRendering(arg2);
38056     } catch (std::out_of_range& e) {
38057       {
38058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38059       };
38060     } catch (std::exception& e) {
38061       {
38062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38063       };
38064     } catch (Dali::DaliException e) {
38065       {
38066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38067       };
38068     } catch (...) {
38069       {
38070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38071       };
38072     }
38073   }
38074
38075 }
38076
38077
38078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38079   void * jresult ;
38080   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38081   Dali::Stage::KeyEventSignalType *result = 0 ;
38082
38083   arg1 = (Dali::Stage *)jarg1;
38084   {
38085     try {
38086       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38087     } catch (std::out_of_range& e) {
38088       {
38089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38090       };
38091     } catch (std::exception& e) {
38092       {
38093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38094       };
38095     } catch (Dali::DaliException e) {
38096       {
38097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38098       };
38099     } catch (...) {
38100       {
38101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38102       };
38103     }
38104   }
38105
38106   jresult = (void *)result;
38107   return jresult;
38108 }
38109
38110
38111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38112   void * jresult ;
38113   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38114   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38115
38116   arg1 = (Dali::Stage *)jarg1;
38117   {
38118     try {
38119       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38120     } catch (std::out_of_range& e) {
38121       {
38122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38123       };
38124     } catch (std::exception& e) {
38125       {
38126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38127       };
38128     } catch (Dali::DaliException e) {
38129       {
38130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38131       };
38132     } catch (...) {
38133       {
38134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38135       };
38136     }
38137   }
38138
38139   jresult = (void *)result;
38140   return jresult;
38141 }
38142
38143
38144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38145   void * jresult ;
38146   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38147   Dali::Stage::TouchSignalType *result = 0 ;
38148
38149   arg1 = (Dali::Stage *)jarg1;
38150   {
38151     try {
38152       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38153     } catch (std::out_of_range& e) {
38154       {
38155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38156       };
38157     } catch (std::exception& e) {
38158       {
38159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38160       };
38161     } catch (Dali::DaliException e) {
38162       {
38163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38164       };
38165     } catch (...) {
38166       {
38167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38168       };
38169     }
38170   }
38171
38172   jresult = (void *)result;
38173   return jresult;
38174 }
38175
38176
38177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38178   void * jresult ;
38179   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38180   Dali::Stage::WheelEventSignalType *result = 0 ;
38181
38182   arg1 = (Dali::Stage *)jarg1;
38183   {
38184     try {
38185       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38186     } catch (std::out_of_range& e) {
38187       {
38188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38189       };
38190     } catch (std::exception& e) {
38191       {
38192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38193       };
38194     } catch (Dali::DaliException e) {
38195       {
38196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38197       };
38198     } catch (...) {
38199       {
38200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38201       };
38202     }
38203   }
38204
38205   jresult = (void *)result;
38206   return jresult;
38207 }
38208
38209
38210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38211   void * jresult ;
38212   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38213   Dali::Stage::ContextStatusSignal *result = 0 ;
38214
38215   arg1 = (Dali::Stage *)jarg1;
38216   {
38217     try {
38218       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38219     } catch (std::out_of_range& e) {
38220       {
38221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38222       };
38223     } catch (std::exception& e) {
38224       {
38225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38226       };
38227     } catch (Dali::DaliException e) {
38228       {
38229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38230       };
38231     } catch (...) {
38232       {
38233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38234       };
38235     }
38236   }
38237
38238   jresult = (void *)result;
38239   return jresult;
38240 }
38241
38242
38243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
38244   void * jresult ;
38245   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38246   Dali::Stage::ContextStatusSignal *result = 0 ;
38247
38248   arg1 = (Dali::Stage *)jarg1;
38249   {
38250     try {
38251       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
38252     } catch (std::out_of_range& e) {
38253       {
38254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38255       };
38256     } catch (std::exception& e) {
38257       {
38258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38259       };
38260     } catch (Dali::DaliException e) {
38261       {
38262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38263       };
38264     } catch (...) {
38265       {
38266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38267       };
38268     }
38269   }
38270
38271   jresult = (void *)result;
38272   return jresult;
38273 }
38274
38275
38276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
38277   void * jresult ;
38278   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38279   Dali::Stage::SceneCreatedSignalType *result = 0 ;
38280
38281   arg1 = (Dali::Stage *)jarg1;
38282   {
38283     try {
38284       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
38285     } catch (std::out_of_range& e) {
38286       {
38287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38288       };
38289     } catch (std::exception& e) {
38290       {
38291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38292       };
38293     } catch (Dali::DaliException e) {
38294       {
38295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38296       };
38297     } catch (...) {
38298       {
38299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38300       };
38301     }
38302   }
38303
38304   jresult = (void *)result;
38305   return jresult;
38306 }
38307
38308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
38309   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38310   Dali::DevelStage::Rendering arg2 ;
38311
38312   arg1 = (Dali::Stage *)jarg1;
38313   arg2 = (Dali::DevelStage::Rendering)jarg2;
38314   {
38315     try {
38316       DevelStage::SetRenderingBehavior(*arg1,arg2);
38317     } catch (std::out_of_range& e) {
38318       {
38319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38320       };
38321     } catch (std::exception& e) {
38322       {
38323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38324       };
38325     } catch (Dali::DaliException e) {
38326       {
38327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38328       };
38329     } catch (...) {
38330       {
38331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38332       };
38333     }
38334   }
38335
38336 }
38337
38338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
38339
38340   int jresult ;
38341   int result ;
38342   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38343
38344   arg1 = (Dali::Stage *)jarg1;
38345   {
38346     try {
38347       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
38348     } catch (std::out_of_range& e) {
38349       {
38350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38351       };
38352     } catch (std::exception& e) {
38353       {
38354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38355       };
38356     } catch (Dali::DaliException e) {
38357       {
38358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38359       };
38360     } catch (...) {
38361       {
38362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38363       };
38364     }
38365   }
38366
38367   jresult = result;
38368   return jresult;
38369 }
38370
38371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
38372   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38373
38374   arg1 = (Dali::RelayoutContainer *)jarg1;
38375   {
38376     try {
38377       delete arg1;
38378     } catch (std::out_of_range& e) {
38379       {
38380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38381       };
38382     } catch (std::exception& e) {
38383       {
38384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38385       };
38386     } catch (Dali::DaliException e) {
38387       {
38388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38389       };
38390     } catch (...) {
38391       {
38392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38393       };
38394     }
38395   }
38396
38397 }
38398
38399
38400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
38401   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38402   Dali::Actor *arg2 = 0 ;
38403   Dali::Vector2 *arg3 = 0 ;
38404
38405   arg1 = (Dali::RelayoutContainer *)jarg1;
38406   arg2 = (Dali::Actor *)jarg2;
38407   if (!arg2) {
38408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
38409     return ;
38410   }
38411   arg3 = (Dali::Vector2 *)jarg3;
38412   if (!arg3) {
38413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38414     return ;
38415   }
38416   {
38417     try {
38418       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
38419     } catch (std::out_of_range& e) {
38420       {
38421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38422       };
38423     } catch (std::exception& e) {
38424       {
38425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38426       };
38427     } catch (Dali::DaliException e) {
38428       {
38429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38430       };
38431     } catch (...) {
38432       {
38433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38434       };
38435     }
38436   }
38437
38438 }
38439
38440
38441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
38442   void * jresult ;
38443   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38444   Dali::CustomActor result;
38445
38446   arg1 = (Dali::CustomActorImpl *)jarg1;
38447   {
38448     try {
38449       result = ((Dali::CustomActorImpl const *)arg1)->Self();
38450     } catch (std::out_of_range& e) {
38451       {
38452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38453       };
38454     } catch (std::exception& e) {
38455       {
38456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38457       };
38458     } catch (Dali::DaliException e) {
38459       {
38460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38461       };
38462     } catch (...) {
38463       {
38464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38465       };
38466     }
38467   }
38468
38469   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
38470   return jresult;
38471 }
38472
38473
38474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
38475   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38476   int arg2 ;
38477
38478   arg1 = (Dali::CustomActorImpl *)jarg1;
38479   arg2 = (int)jarg2;
38480   {
38481     try {
38482       (arg1)->OnSceneConnection(arg2);
38483     } catch (std::out_of_range& e) {
38484       {
38485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38486       };
38487     } catch (std::exception& e) {
38488       {
38489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38490       };
38491     } catch (Dali::DaliException e) {
38492       {
38493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38494       };
38495     } catch (...) {
38496       {
38497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38498       };
38499     }
38500   }
38501
38502 }
38503
38504
38505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
38506   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38507
38508   arg1 = (Dali::CustomActorImpl *)jarg1;
38509   {
38510     try {
38511       (arg1)->OnSceneDisconnection();
38512     } catch (std::out_of_range& e) {
38513       {
38514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38515       };
38516     } catch (std::exception& e) {
38517       {
38518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38519       };
38520     } catch (Dali::DaliException e) {
38521       {
38522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38523       };
38524     } catch (...) {
38525       {
38526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38527       };
38528     }
38529   }
38530
38531 }
38532
38533
38534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
38535   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38536   Dali::Actor *arg2 = 0 ;
38537
38538   arg1 = (Dali::CustomActorImpl *)jarg1;
38539   arg2 = (Dali::Actor *)jarg2;
38540   if (!arg2) {
38541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38542     return ;
38543   }
38544   {
38545     try {
38546       (arg1)->OnChildAdd(*arg2);
38547     } catch (std::out_of_range& e) {
38548       {
38549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38550       };
38551     } catch (std::exception& e) {
38552       {
38553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38554       };
38555     } catch (Dali::DaliException e) {
38556       {
38557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38558       };
38559     } catch (...) {
38560       {
38561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38562       };
38563     }
38564   }
38565
38566 }
38567
38568
38569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
38570   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38571   Dali::Actor *arg2 = 0 ;
38572
38573   arg1 = (Dali::CustomActorImpl *)jarg1;
38574   arg2 = (Dali::Actor *)jarg2;
38575   if (!arg2) {
38576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38577     return ;
38578   }
38579   {
38580     try {
38581       (arg1)->OnChildRemove(*arg2);
38582     } catch (std::out_of_range& e) {
38583       {
38584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38585       };
38586     } catch (std::exception& e) {
38587       {
38588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38589       };
38590     } catch (Dali::DaliException e) {
38591       {
38592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38593       };
38594     } catch (...) {
38595       {
38596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38597       };
38598     }
38599   }
38600
38601 }
38602
38603
38604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
38605   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38606   Dali::Property::Index arg2 ;
38607   Dali::Property::Value arg3 ;
38608   Dali::Property::Value *argp3 ;
38609
38610   arg1 = (Dali::CustomActorImpl *)jarg1;
38611   arg2 = (Dali::Property::Index)jarg2;
38612   argp3 = (Dali::Property::Value *)jarg3;
38613   if (!argp3) {
38614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
38615     return ;
38616   }
38617   arg3 = *argp3;
38618   {
38619     try {
38620       (arg1)->OnPropertySet(arg2,arg3);
38621     } catch (std::out_of_range& e) {
38622       {
38623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38624       };
38625     } catch (std::exception& e) {
38626       {
38627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38628       };
38629     } catch (Dali::DaliException e) {
38630       {
38631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38632       };
38633     } catch (...) {
38634       {
38635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38636       };
38637     }
38638   }
38639
38640 }
38641
38642
38643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
38644   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38645   Dali::Vector3 *arg2 = 0 ;
38646
38647   arg1 = (Dali::CustomActorImpl *)jarg1;
38648   arg2 = (Dali::Vector3 *)jarg2;
38649   if (!arg2) {
38650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38651     return ;
38652   }
38653   {
38654     try {
38655       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
38656     } catch (std::out_of_range& e) {
38657       {
38658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38659       };
38660     } catch (std::exception& e) {
38661       {
38662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38663       };
38664     } catch (Dali::DaliException e) {
38665       {
38666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38667       };
38668     } catch (...) {
38669       {
38670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38671       };
38672     }
38673   }
38674
38675 }
38676
38677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
38678   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38679   Dali::Animation *arg2 = 0 ;
38680   Dali::Vector3 *arg3 = 0 ;
38681
38682   arg1 = (Dali::CustomActorImpl *)jarg1;
38683   arg2 = (Dali::Animation *)jarg2;
38684   if (!arg2) {
38685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
38686     return ;
38687   }
38688   arg3 = (Dali::Vector3 *)jarg3;
38689   if (!arg3) {
38690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38691     return ;
38692   }
38693   {
38694     try {
38695       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
38696     } catch (std::out_of_range& e) {
38697       {
38698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38699       };
38700     } catch (std::exception& e) {
38701       {
38702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38703       };
38704     } catch (Dali::DaliException e) {
38705       {
38706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38707       };
38708     } catch (...) {
38709       {
38710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38711       };
38712     }
38713   }
38714 }
38715
38716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
38717   unsigned int jresult ;
38718   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38719   Dali::HoverEvent *arg2 = 0 ;
38720   bool result;
38721
38722   arg1 = (Dali::CustomActorImpl *)jarg1;
38723   arg2 = (Dali::HoverEvent *)jarg2;
38724   if (!arg2) {
38725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
38726     return 0;
38727   }
38728   {
38729     try {
38730       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
38731     } catch (std::out_of_range& e) {
38732       {
38733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38734       };
38735     } catch (std::exception& e) {
38736       {
38737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38738       };
38739     } catch (Dali::DaliException e) {
38740       {
38741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38742       };
38743     } catch (...) {
38744       {
38745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38746       };
38747     }
38748   }
38749
38750   jresult = result;
38751   return jresult;
38752 }
38753
38754
38755 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
38756   unsigned int jresult ;
38757   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38758   Dali::KeyEvent *arg2 = 0 ;
38759   bool result;
38760
38761   arg1 = (Dali::CustomActorImpl *)jarg1;
38762   arg2 = (Dali::KeyEvent *)jarg2;
38763   if (!arg2) {
38764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
38765     return 0;
38766   }
38767   {
38768     try {
38769       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
38770     } catch (std::out_of_range& e) {
38771       {
38772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38773       };
38774     } catch (std::exception& e) {
38775       {
38776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38777       };
38778     } catch (Dali::DaliException e) {
38779       {
38780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38781       };
38782     } catch (...) {
38783       {
38784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38785       };
38786     }
38787   }
38788
38789   jresult = result;
38790   return jresult;
38791 }
38792
38793
38794 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
38795   unsigned int jresult ;
38796   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38797   Dali::WheelEvent *arg2 = 0 ;
38798   bool result;
38799
38800   arg1 = (Dali::CustomActorImpl *)jarg1;
38801   arg2 = (Dali::WheelEvent *)jarg2;
38802   if (!arg2) {
38803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
38804     return 0;
38805   }
38806   {
38807     try {
38808       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
38809     } catch (std::out_of_range& e) {
38810       {
38811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38812       };
38813     } catch (std::exception& e) {
38814       {
38815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38816       };
38817     } catch (Dali::DaliException e) {
38818       {
38819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38820       };
38821     } catch (...) {
38822       {
38823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38824       };
38825     }
38826   }
38827
38828   jresult = result;
38829   return jresult;
38830 }
38831
38832
38833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
38834   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38835   Dali::Vector2 *arg2 = 0 ;
38836   Dali::RelayoutContainer *arg3 = 0 ;
38837
38838   arg1 = (Dali::CustomActorImpl *)jarg1;
38839   arg2 = (Dali::Vector2 *)jarg2;
38840   if (!arg2) {
38841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38842     return ;
38843   }
38844   arg3 = (Dali::RelayoutContainer *)jarg3;
38845   if (!arg3) {
38846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
38847     return ;
38848   }
38849   {
38850     try {
38851       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*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
38873
38874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
38875   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38876   Dali::ResizePolicy::Type arg2 ;
38877   Dali::Dimension::Type arg3 ;
38878
38879   arg1 = (Dali::CustomActorImpl *)jarg1;
38880   arg2 = (Dali::ResizePolicy::Type)jarg2;
38881   arg3 = (Dali::Dimension::Type)jarg3;
38882   {
38883     try {
38884       (arg1)->OnSetResizePolicy(arg2,arg3);
38885     } catch (std::out_of_range& e) {
38886       {
38887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38888       };
38889     } catch (std::exception& e) {
38890       {
38891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38892       };
38893     } catch (Dali::DaliException e) {
38894       {
38895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38896       };
38897     } catch (...) {
38898       {
38899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38900       };
38901     }
38902   }
38903
38904 }
38905
38906
38907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
38908   void * jresult ;
38909   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38910   Dali::Vector3 result;
38911
38912   arg1 = (Dali::CustomActorImpl *)jarg1;
38913   {
38914     try {
38915       result = (arg1)->GetNaturalSize();
38916     } catch (std::out_of_range& e) {
38917       {
38918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38919       };
38920     } catch (std::exception& e) {
38921       {
38922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38923       };
38924     } catch (Dali::DaliException e) {
38925       {
38926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38927       };
38928     } catch (...) {
38929       {
38930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38931       };
38932     }
38933   }
38934
38935   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
38936   return jresult;
38937 }
38938
38939
38940 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
38941   float jresult ;
38942   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38943   Dali::Actor *arg2 = 0 ;
38944   Dali::Dimension::Type arg3 ;
38945   float result;
38946
38947   arg1 = (Dali::CustomActorImpl *)jarg1;
38948   arg2 = (Dali::Actor *)jarg2;
38949   if (!arg2) {
38950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
38951     return 0;
38952   }
38953   arg3 = (Dali::Dimension::Type)jarg3;
38954   {
38955     try {
38956       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
38957     } catch (std::out_of_range& e) {
38958       {
38959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38960       };
38961     } catch (std::exception& e) {
38962       {
38963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38964       };
38965     } catch (Dali::DaliException e) {
38966       {
38967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38968       };
38969     } catch (...) {
38970       {
38971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38972       };
38973     }
38974   }
38975
38976   jresult = result;
38977   return jresult;
38978 }
38979
38980
38981 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
38982   float jresult ;
38983   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38984   float arg2 ;
38985   float result;
38986
38987   arg1 = (Dali::CustomActorImpl *)jarg1;
38988   arg2 = (float)jarg2;
38989   {
38990     try {
38991       result = (float)(arg1)->GetHeightForWidth(arg2);
38992     } catch (std::out_of_range& e) {
38993       {
38994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38995       };
38996     } catch (std::exception& e) {
38997       {
38998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38999       };
39000     } catch (Dali::DaliException e) {
39001       {
39002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39003       };
39004     } catch (...) {
39005       {
39006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39007       };
39008     }
39009   }
39010
39011   jresult = result;
39012   return jresult;
39013 }
39014
39015
39016 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39017   float jresult ;
39018   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39019   float arg2 ;
39020   float result;
39021
39022   arg1 = (Dali::CustomActorImpl *)jarg1;
39023   arg2 = (float)jarg2;
39024   {
39025     try {
39026       result = (float)(arg1)->GetWidthForHeight(arg2);
39027     } catch (std::out_of_range& e) {
39028       {
39029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39030       };
39031     } catch (std::exception& e) {
39032       {
39033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39034       };
39035     } catch (Dali::DaliException e) {
39036       {
39037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39038       };
39039     } catch (...) {
39040       {
39041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39042       };
39043     }
39044   }
39045
39046   jresult = result;
39047   return jresult;
39048 }
39049
39050
39051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39052   unsigned int jresult ;
39053   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39054   Dali::Dimension::Type arg2 ;
39055   bool result;
39056
39057   arg1 = (Dali::CustomActorImpl *)jarg1;
39058   arg2 = (Dali::Dimension::Type)jarg2;
39059   {
39060     try {
39061       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39062     } catch (std::out_of_range& e) {
39063       {
39064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39065       };
39066     } catch (std::exception& e) {
39067       {
39068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39069       };
39070     } catch (Dali::DaliException e) {
39071       {
39072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39073       };
39074     } catch (...) {
39075       {
39076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39077       };
39078     }
39079   }
39080
39081   jresult = result;
39082   return jresult;
39083 }
39084
39085
39086 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39087   unsigned int jresult ;
39088   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39089   bool result;
39090
39091   arg1 = (Dali::CustomActorImpl *)jarg1;
39092   {
39093     try {
39094       result = (bool)(arg1)->RelayoutDependentOnChildren();
39095     } catch (std::out_of_range& e) {
39096       {
39097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39098       };
39099     } catch (std::exception& e) {
39100       {
39101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39102       };
39103     } catch (Dali::DaliException e) {
39104       {
39105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39106       };
39107     } catch (...) {
39108       {
39109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39110       };
39111     }
39112   }
39113
39114   jresult = result;
39115   return jresult;
39116 }
39117
39118
39119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39120   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39121   Dali::Dimension::Type arg2 ;
39122
39123   arg1 = (Dali::CustomActorImpl *)jarg1;
39124   arg2 = (Dali::Dimension::Type)jarg2;
39125   {
39126     try {
39127       (arg1)->OnCalculateRelayoutSize(arg2);
39128     } catch (std::out_of_range& e) {
39129       {
39130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39131       };
39132     } catch (std::exception& e) {
39133       {
39134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39135       };
39136     } catch (Dali::DaliException e) {
39137       {
39138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39139       };
39140     } catch (...) {
39141       {
39142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39143       };
39144     }
39145   }
39146
39147 }
39148
39149
39150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39151   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39152   float arg2 ;
39153   Dali::Dimension::Type arg3 ;
39154
39155   arg1 = (Dali::CustomActorImpl *)jarg1;
39156   arg2 = (float)jarg2;
39157   arg3 = (Dali::Dimension::Type)jarg3;
39158   {
39159     try {
39160       (arg1)->OnLayoutNegotiated(arg2,arg3);
39161     } catch (std::out_of_range& e) {
39162       {
39163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39164       };
39165     } catch (std::exception& e) {
39166       {
39167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39168       };
39169     } catch (Dali::DaliException e) {
39170       {
39171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39172       };
39173     } catch (...) {
39174       {
39175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39176       };
39177     }
39178   }
39179
39180 }
39181
39182
39183 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39184   unsigned int jresult ;
39185   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39186   bool result;
39187
39188   arg1 = (Dali::CustomActorImpl *)jarg1;
39189   {
39190     try {
39191       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39192     } catch (std::out_of_range& e) {
39193       {
39194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39195       };
39196     } catch (std::exception& e) {
39197       {
39198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39199       };
39200     } catch (Dali::DaliException e) {
39201       {
39202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39203       };
39204     } catch (...) {
39205       {
39206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39207       };
39208     }
39209   }
39210
39211   jresult = result;
39212   return jresult;
39213 }
39214
39215
39216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39217   unsigned int jresult ;
39218   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39219   bool result;
39220
39221   arg1 = (Dali::CustomActorImpl *)jarg1;
39222   {
39223     try {
39224       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39225     } catch (std::out_of_range& e) {
39226       {
39227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39228       };
39229     } catch (std::exception& e) {
39230       {
39231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39232       };
39233     } catch (Dali::DaliException e) {
39234       {
39235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39236       };
39237     } catch (...) {
39238       {
39239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39240       };
39241     }
39242   }
39243
39244   jresult = result;
39245   return jresult;
39246 }
39247
39248
39249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
39250   unsigned int jresult ;
39251   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39252   bool result;
39253
39254   arg1 = (Dali::CustomActorImpl *)jarg1;
39255   {
39256     try {
39257       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
39258     } catch (std::out_of_range& e) {
39259       {
39260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39261       };
39262     } catch (std::exception& e) {
39263       {
39264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39265       };
39266     } catch (Dali::DaliException e) {
39267       {
39268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39269       };
39270     } catch (...) {
39271       {
39272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39273       };
39274     }
39275   }
39276
39277   jresult = result;
39278   return jresult;
39279 }
39280
39281
39282 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
39283   unsigned int jresult ;
39284   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39285   bool result;
39286
39287   arg1 = (Dali::CustomActorImpl *)jarg1;
39288   {
39289     try {
39290       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
39291     } catch (std::out_of_range& e) {
39292       {
39293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39294       };
39295     } catch (std::exception& e) {
39296       {
39297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39298       };
39299     } catch (Dali::DaliException e) {
39300       {
39301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39302       };
39303     } catch (...) {
39304       {
39305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39306       };
39307     }
39308   }
39309
39310   jresult = result;
39311   return jresult;
39312 }
39313
39314
39315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
39316   void * jresult ;
39317   Dali::CustomActor *result = 0 ;
39318
39319   {
39320     try {
39321       result = (Dali::CustomActor *)new Dali::CustomActor();
39322     } catch (std::out_of_range& e) {
39323       {
39324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39325       };
39326     } catch (std::exception& e) {
39327       {
39328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39329       };
39330     } catch (Dali::DaliException e) {
39331       {
39332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39333       };
39334     } catch (...) {
39335       {
39336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39337       };
39338     }
39339   }
39340
39341   jresult = (void *)result;
39342   return jresult;
39343 }
39344
39345
39346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
39347   void * jresult ;
39348   Dali::BaseHandle arg1 ;
39349   Dali::BaseHandle *argp1 ;
39350   Dali::CustomActor result;
39351
39352   argp1 = (Dali::BaseHandle *)jarg1;
39353   if (!argp1) {
39354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39355     return 0;
39356   }
39357   arg1 = *argp1;
39358   {
39359     try {
39360       result = Dali::CustomActor::DownCast(arg1);
39361     } catch (std::out_of_range& e) {
39362       {
39363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39364       };
39365     } catch (std::exception& e) {
39366       {
39367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39368       };
39369     } catch (Dali::DaliException e) {
39370       {
39371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39372       };
39373     } catch (...) {
39374       {
39375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39376       };
39377     }
39378   }
39379
39380   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39381   return jresult;
39382 }
39383
39384
39385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
39386   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39387
39388   arg1 = (Dali::CustomActor *)jarg1;
39389   {
39390     try {
39391       delete arg1;
39392     } catch (std::out_of_range& e) {
39393       {
39394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39395       };
39396     } catch (std::exception& e) {
39397       {
39398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39399       };
39400     } catch (Dali::DaliException e) {
39401       {
39402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39403       };
39404     } catch (...) {
39405       {
39406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39407       };
39408     }
39409   }
39410
39411 }
39412
39413
39414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
39415   void * jresult ;
39416   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39417   Dali::CustomActorImpl *result = 0 ;
39418
39419   arg1 = (Dali::CustomActor *)jarg1;
39420   {
39421     try {
39422       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
39423     } catch (std::out_of_range& e) {
39424       {
39425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39426       };
39427     } catch (std::exception& e) {
39428       {
39429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39430       };
39431     } catch (Dali::DaliException e) {
39432       {
39433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39434       };
39435     } catch (...) {
39436       {
39437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39438       };
39439     }
39440   }
39441
39442   jresult = (void *)result;
39443   return jresult;
39444 }
39445
39446
39447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
39448   void * jresult ;
39449   Dali::CustomActorImpl *arg1 = 0 ;
39450   Dali::CustomActor *result = 0 ;
39451
39452   arg1 = (Dali::CustomActorImpl *)jarg1;
39453   if (!arg1) {
39454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
39455     return 0;
39456   }
39457   {
39458     try {
39459       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
39460     } catch (std::out_of_range& e) {
39461       {
39462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39463       };
39464     } catch (std::exception& e) {
39465       {
39466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39467       };
39468     } catch (Dali::DaliException e) {
39469       {
39470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39471       };
39472     } catch (...) {
39473       {
39474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39475       };
39476     }
39477   }
39478
39479   jresult = (void *)result;
39480   return jresult;
39481 }
39482
39483
39484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
39485   void * jresult ;
39486   Dali::CustomActor *arg1 = 0 ;
39487   Dali::CustomActor *result = 0 ;
39488
39489   arg1 = (Dali::CustomActor *)jarg1;
39490   if (!arg1) {
39491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
39492     return 0;
39493   }
39494   {
39495     try {
39496       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
39497     } catch (std::out_of_range& e) {
39498       {
39499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39500       };
39501     } catch (std::exception& e) {
39502       {
39503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39504       };
39505     } catch (Dali::DaliException e) {
39506       {
39507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39508       };
39509     } catch (...) {
39510       {
39511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39512       };
39513     }
39514   }
39515
39516   jresult = (void *)result;
39517   return jresult;
39518 }
39519
39520
39521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
39522   void * jresult ;
39523   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39524   Dali::CustomActor *arg2 = 0 ;
39525   Dali::CustomActor *result = 0 ;
39526
39527   arg1 = (Dali::CustomActor *)jarg1;
39528   arg2 = (Dali::CustomActor *)jarg2;
39529   if (!arg2) {
39530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
39531     return 0;
39532   }
39533   {
39534     try {
39535       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
39536     } catch (std::out_of_range& e) {
39537       {
39538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39539       };
39540     } catch (std::exception& e) {
39541       {
39542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39543       };
39544     } catch (Dali::DaliException e) {
39545       {
39546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39547       };
39548     } catch (...) {
39549       {
39550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39551       };
39552     }
39553   }
39554
39555   jresult = (void *)result;
39556   return jresult;
39557 }
39558
39559
39560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
39561   int jresult ;
39562   int result;
39563
39564   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
39565   jresult = (int)result;
39566   return jresult;
39567 }
39568
39569
39570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
39571   int jresult ;
39572   int result;
39573
39574   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
39575   jresult = (int)result;
39576   return jresult;
39577 }
39578
39579
39580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
39581   int jresult ;
39582   int result;
39583
39584   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
39585   jresult = (int)result;
39586   return jresult;
39587 }
39588
39589
39590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
39591   int jresult ;
39592   int result;
39593
39594   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
39595   jresult = (int)result;
39596   return jresult;
39597 }
39598
39599
39600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
39601   int jresult ;
39602   int result;
39603
39604   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
39605   jresult = (int)result;
39606   return jresult;
39607 }
39608
39609
39610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
39611   int jresult ;
39612   int result;
39613
39614   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
39615   jresult = (int)result;
39616   return jresult;
39617 }
39618
39619
39620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
39621   int jresult ;
39622   int result;
39623
39624   result = (int)Dali::PanGestureDetector::Property::PANNING;
39625   jresult = (int)result;
39626   return jresult;
39627 }
39628
39629
39630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
39631   void * jresult ;
39632   Dali::PanGestureDetector::Property *result = 0 ;
39633
39634   {
39635     try {
39636       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
39637     } catch (std::out_of_range& e) {
39638       {
39639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39640       };
39641     } catch (std::exception& e) {
39642       {
39643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39644       };
39645     } catch (Dali::DaliException e) {
39646       {
39647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39648       };
39649     } catch (...) {
39650       {
39651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39652       };
39653     }
39654   }
39655
39656   jresult = (void *)result;
39657   return jresult;
39658 }
39659
39660
39661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
39662   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
39663
39664   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
39665   {
39666     try {
39667       delete arg1;
39668     } catch (std::out_of_range& e) {
39669       {
39670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39671       };
39672     } catch (std::exception& e) {
39673       {
39674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39675       };
39676     } catch (Dali::DaliException e) {
39677       {
39678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39679       };
39680     } catch (...) {
39681       {
39682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39683       };
39684     }
39685   }
39686
39687 }
39688
39689
39690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
39691   void * jresult ;
39692   Dali::Radian *result = 0 ;
39693
39694   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
39695   jresult = (void *)result;
39696   return jresult;
39697 }
39698
39699
39700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
39701   void * jresult ;
39702   Dali::Radian *result = 0 ;
39703
39704   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
39705   jresult = (void *)result;
39706   return jresult;
39707 }
39708
39709
39710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
39711   void * jresult ;
39712   Dali::Radian *result = 0 ;
39713
39714   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
39715   jresult = (void *)result;
39716   return jresult;
39717 }
39718
39719
39720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
39721   void * jresult ;
39722   Dali::Radian *result = 0 ;
39723
39724   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
39725   jresult = (void *)result;
39726   return jresult;
39727 }
39728
39729
39730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
39731   void * jresult ;
39732   Dali::Radian *result = 0 ;
39733
39734   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
39735   jresult = (void *)result;
39736   return jresult;
39737 }
39738
39739
39740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
39741   void * jresult ;
39742   Dali::Radian *result = 0 ;
39743
39744   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
39745   jresult = (void *)result;
39746   return jresult;
39747 }
39748
39749
39750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
39751   void * jresult ;
39752   Dali::Radian *result = 0 ;
39753
39754   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
39755   jresult = (void *)result;
39756   return jresult;
39757 }
39758
39759
39760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
39761   void * jresult ;
39762   Dali::PanGestureDetector *result = 0 ;
39763
39764   {
39765     try {
39766       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
39767     } catch (std::out_of_range& e) {
39768       {
39769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39770       };
39771     } catch (std::exception& e) {
39772       {
39773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39774       };
39775     } catch (Dali::DaliException e) {
39776       {
39777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39778       };
39779     } catch (...) {
39780       {
39781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39782       };
39783     }
39784   }
39785
39786   jresult = (void *)result;
39787   return jresult;
39788 }
39789
39790
39791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
39792   void * jresult ;
39793   Dali::PanGestureDetector result;
39794
39795   {
39796     try {
39797       result = Dali::PanGestureDetector::New();
39798     } catch (std::out_of_range& e) {
39799       {
39800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39801       };
39802     } catch (std::exception& e) {
39803       {
39804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39805       };
39806     } catch (Dali::DaliException e) {
39807       {
39808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39809       };
39810     } catch (...) {
39811       {
39812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39813       };
39814     }
39815   }
39816
39817   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
39818   return jresult;
39819 }
39820
39821
39822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
39823   void * jresult ;
39824   Dali::BaseHandle arg1 ;
39825   Dali::BaseHandle *argp1 ;
39826   Dali::PanGestureDetector result;
39827
39828   argp1 = (Dali::BaseHandle *)jarg1;
39829   if (!argp1) {
39830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39831     return 0;
39832   }
39833   arg1 = *argp1;
39834   {
39835     try {
39836       result = Dali::PanGestureDetector::DownCast(arg1);
39837     } catch (std::out_of_range& e) {
39838       {
39839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39840       };
39841     } catch (std::exception& e) {
39842       {
39843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39844       };
39845     } catch (Dali::DaliException e) {
39846       {
39847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39848       };
39849     } catch (...) {
39850       {
39851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39852       };
39853     }
39854   }
39855
39856   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
39857   return jresult;
39858 }
39859
39860
39861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
39862   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
39863
39864   arg1 = (Dali::PanGestureDetector *)jarg1;
39865   {
39866     try {
39867       delete arg1;
39868     } catch (std::out_of_range& e) {
39869       {
39870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39871       };
39872     } catch (std::exception& e) {
39873       {
39874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39875       };
39876     } catch (Dali::DaliException e) {
39877       {
39878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39879       };
39880     } catch (...) {
39881       {
39882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39883       };
39884     }
39885   }
39886
39887 }
39888
39889
39890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
39891   void * jresult ;
39892   Dali::PanGestureDetector *arg1 = 0 ;
39893   Dali::PanGestureDetector *result = 0 ;
39894
39895   arg1 = (Dali::PanGestureDetector *)jarg1;
39896   if (!arg1) {
39897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
39898     return 0;
39899   }
39900   {
39901     try {
39902       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
39903     } catch (std::out_of_range& e) {
39904       {
39905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39906       };
39907     } catch (std::exception& e) {
39908       {
39909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39910       };
39911     } catch (Dali::DaliException e) {
39912       {
39913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39914       };
39915     } catch (...) {
39916       {
39917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39918       };
39919     }
39920   }
39921
39922   jresult = (void *)result;
39923   return jresult;
39924 }
39925
39926
39927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
39928   void * jresult ;
39929   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
39930   Dali::PanGestureDetector *arg2 = 0 ;
39931   Dali::PanGestureDetector *result = 0 ;
39932
39933   arg1 = (Dali::PanGestureDetector *)jarg1;
39934   arg2 = (Dali::PanGestureDetector *)jarg2;
39935   if (!arg2) {
39936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
39937     return 0;
39938   }
39939   {
39940     try {
39941       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
39942     } catch (std::out_of_range& e) {
39943       {
39944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39945       };
39946     } catch (std::exception& e) {
39947       {
39948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39949       };
39950     } catch (Dali::DaliException e) {
39951       {
39952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39953       };
39954     } catch (...) {
39955       {
39956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39957       };
39958     }
39959   }
39960
39961   jresult = (void *)result;
39962   return jresult;
39963 }
39964
39965
39966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
39967   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
39968   unsigned int arg2 ;
39969
39970   arg1 = (Dali::PanGestureDetector *)jarg1;
39971   arg2 = (unsigned int)jarg2;
39972   {
39973     try {
39974       (arg1)->SetMinimumTouchesRequired(arg2);
39975     } catch (std::out_of_range& e) {
39976       {
39977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39978       };
39979     } catch (std::exception& e) {
39980       {
39981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39982       };
39983     } catch (Dali::DaliException e) {
39984       {
39985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39986       };
39987     } catch (...) {
39988       {
39989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39990       };
39991     }
39992   }
39993
39994 }
39995
39996
39997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
39998   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
39999   unsigned int arg2 ;
40000
40001   arg1 = (Dali::PanGestureDetector *)jarg1;
40002   arg2 = (unsigned int)jarg2;
40003   {
40004     try {
40005       (arg1)->SetMaximumTouchesRequired(arg2);
40006     } catch (std::out_of_range& e) {
40007       {
40008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40009       };
40010     } catch (std::exception& e) {
40011       {
40012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40013       };
40014     } catch (Dali::DaliException e) {
40015       {
40016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40017       };
40018     } catch (...) {
40019       {
40020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40021       };
40022     }
40023   }
40024
40025 }
40026
40027
40028 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40029   unsigned int jresult ;
40030   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40031   unsigned int result;
40032
40033   arg1 = (Dali::PanGestureDetector *)jarg1;
40034   {
40035     try {
40036       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40037     } catch (std::out_of_range& e) {
40038       {
40039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40040       };
40041     } catch (std::exception& e) {
40042       {
40043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40044       };
40045     } catch (Dali::DaliException e) {
40046       {
40047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40048       };
40049     } catch (...) {
40050       {
40051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40052       };
40053     }
40054   }
40055
40056   jresult = result;
40057   return jresult;
40058 }
40059
40060
40061 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40062   unsigned int jresult ;
40063   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40064   unsigned int result;
40065
40066   arg1 = (Dali::PanGestureDetector *)jarg1;
40067   {
40068     try {
40069       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40070     } catch (std::out_of_range& e) {
40071       {
40072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40073       };
40074     } catch (std::exception& e) {
40075       {
40076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40077       };
40078     } catch (Dali::DaliException e) {
40079       {
40080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40081       };
40082     } catch (...) {
40083       {
40084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40085       };
40086     }
40087   }
40088
40089   jresult = result;
40090   return jresult;
40091 }
40092
40093
40094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40095   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40096   Dali::Radian arg2 ;
40097   Dali::Radian arg3 ;
40098   Dali::Radian *argp2 ;
40099   Dali::Radian *argp3 ;
40100
40101   arg1 = (Dali::PanGestureDetector *)jarg1;
40102   argp2 = (Dali::Radian *)jarg2;
40103   if (!argp2) {
40104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40105     return ;
40106   }
40107   arg2 = *argp2;
40108   argp3 = (Dali::Radian *)jarg3;
40109   if (!argp3) {
40110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40111     return ;
40112   }
40113   arg3 = *argp3;
40114   {
40115     try {
40116       (arg1)->AddAngle(arg2,arg3);
40117     } catch (std::out_of_range& e) {
40118       {
40119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40120       };
40121     } catch (std::exception& e) {
40122       {
40123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40124       };
40125     } catch (Dali::DaliException e) {
40126       {
40127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40128       };
40129     } catch (...) {
40130       {
40131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40132       };
40133     }
40134   }
40135
40136 }
40137
40138
40139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40140   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40141   Dali::Radian arg2 ;
40142   Dali::Radian *argp2 ;
40143
40144   arg1 = (Dali::PanGestureDetector *)jarg1;
40145   argp2 = (Dali::Radian *)jarg2;
40146   if (!argp2) {
40147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40148     return ;
40149   }
40150   arg2 = *argp2;
40151   {
40152     try {
40153       (arg1)->AddAngle(arg2);
40154     } catch (std::out_of_range& e) {
40155       {
40156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40157       };
40158     } catch (std::exception& e) {
40159       {
40160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40161       };
40162     } catch (Dali::DaliException e) {
40163       {
40164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40165       };
40166     } catch (...) {
40167       {
40168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40169       };
40170     }
40171   }
40172
40173 }
40174
40175
40176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40177   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40178   Dali::Radian arg2 ;
40179   Dali::Radian arg3 ;
40180   Dali::Radian *argp2 ;
40181   Dali::Radian *argp3 ;
40182
40183   arg1 = (Dali::PanGestureDetector *)jarg1;
40184   argp2 = (Dali::Radian *)jarg2;
40185   if (!argp2) {
40186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40187     return ;
40188   }
40189   arg2 = *argp2;
40190   argp3 = (Dali::Radian *)jarg3;
40191   if (!argp3) {
40192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40193     return ;
40194   }
40195   arg3 = *argp3;
40196   {
40197     try {
40198       (arg1)->AddDirection(arg2,arg3);
40199     } catch (std::out_of_range& e) {
40200       {
40201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40202       };
40203     } catch (std::exception& e) {
40204       {
40205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40206       };
40207     } catch (Dali::DaliException e) {
40208       {
40209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40210       };
40211     } catch (...) {
40212       {
40213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40214       };
40215     }
40216   }
40217
40218 }
40219
40220
40221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40222   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40223   Dali::Radian arg2 ;
40224   Dali::Radian *argp2 ;
40225
40226   arg1 = (Dali::PanGestureDetector *)jarg1;
40227   argp2 = (Dali::Radian *)jarg2;
40228   if (!argp2) {
40229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40230     return ;
40231   }
40232   arg2 = *argp2;
40233   {
40234     try {
40235       (arg1)->AddDirection(arg2);
40236     } catch (std::out_of_range& e) {
40237       {
40238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40239       };
40240     } catch (std::exception& e) {
40241       {
40242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40243       };
40244     } catch (Dali::DaliException e) {
40245       {
40246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40247       };
40248     } catch (...) {
40249       {
40250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40251       };
40252     }
40253   }
40254
40255 }
40256
40257
40258 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
40259   unsigned long jresult ;
40260   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40261   size_t result;
40262
40263   arg1 = (Dali::PanGestureDetector *)jarg1;
40264   {
40265     try {
40266       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
40267     } catch (std::out_of_range& e) {
40268       {
40269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40270       };
40271     } catch (std::exception& e) {
40272       {
40273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40274       };
40275     } catch (Dali::DaliException e) {
40276       {
40277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40278       };
40279     } catch (...) {
40280       {
40281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40282       };
40283     }
40284   }
40285
40286   jresult = (unsigned long)result;
40287   return jresult;
40288 }
40289
40290
40291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
40292   void * jresult ;
40293   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40294   size_t arg2 ;
40295   Dali::PanGestureDetector::AngleThresholdPair result;
40296
40297   arg1 = (Dali::PanGestureDetector *)jarg1;
40298   arg2 = (size_t)jarg2;
40299   {
40300     try {
40301       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
40302     } catch (std::out_of_range& e) {
40303       {
40304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40305       };
40306     } catch (std::exception& e) {
40307       {
40308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40309       };
40310     } catch (Dali::DaliException e) {
40311       {
40312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40313       };
40314     } catch (...) {
40315       {
40316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40317       };
40318     }
40319   }
40320
40321   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
40322   return jresult;
40323 }
40324
40325
40326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
40327   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40328
40329   arg1 = (Dali::PanGestureDetector *)jarg1;
40330   {
40331     try {
40332       (arg1)->ClearAngles();
40333     } catch (std::out_of_range& e) {
40334       {
40335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40336       };
40337     } catch (std::exception& e) {
40338       {
40339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40340       };
40341     } catch (Dali::DaliException e) {
40342       {
40343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40344       };
40345     } catch (...) {
40346       {
40347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40348       };
40349     }
40350   }
40351
40352 }
40353
40354
40355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
40356   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40357   Dali::Radian arg2 ;
40358   Dali::Radian *argp2 ;
40359
40360   arg1 = (Dali::PanGestureDetector *)jarg1;
40361   argp2 = (Dali::Radian *)jarg2;
40362   if (!argp2) {
40363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40364     return ;
40365   }
40366   arg2 = *argp2;
40367   {
40368     try {
40369       (arg1)->RemoveAngle(arg2);
40370     } catch (std::out_of_range& e) {
40371       {
40372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40373       };
40374     } catch (std::exception& e) {
40375       {
40376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40377       };
40378     } catch (Dali::DaliException e) {
40379       {
40380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40381       };
40382     } catch (...) {
40383       {
40384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40385       };
40386     }
40387   }
40388
40389 }
40390
40391
40392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
40393   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40394   Dali::Radian arg2 ;
40395   Dali::Radian *argp2 ;
40396
40397   arg1 = (Dali::PanGestureDetector *)jarg1;
40398   argp2 = (Dali::Radian *)jarg2;
40399   if (!argp2) {
40400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40401     return ;
40402   }
40403   arg2 = *argp2;
40404   {
40405     try {
40406       (arg1)->RemoveDirection(arg2);
40407     } catch (std::out_of_range& e) {
40408       {
40409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40410       };
40411     } catch (std::exception& e) {
40412       {
40413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40414       };
40415     } catch (Dali::DaliException e) {
40416       {
40417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40418       };
40419     } catch (...) {
40420       {
40421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40422       };
40423     }
40424   }
40425
40426 }
40427
40428
40429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
40430   void * jresult ;
40431   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40432   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
40433
40434   arg1 = (Dali::PanGestureDetector *)jarg1;
40435   {
40436     try {
40437       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
40438     } catch (std::out_of_range& e) {
40439       {
40440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40441       };
40442     } catch (std::exception& e) {
40443       {
40444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40445       };
40446     } catch (Dali::DaliException e) {
40447       {
40448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40449       };
40450     } catch (...) {
40451       {
40452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40453       };
40454     }
40455   }
40456
40457   jresult = (void *)result;
40458   return jresult;
40459 }
40460
40461
40462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
40463   Dali::PanGesture *arg1 = 0 ;
40464
40465   arg1 = (Dali::PanGesture *)jarg1;
40466   if (!arg1) {
40467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40468     return ;
40469   }
40470   {
40471     try {
40472       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
40473     } catch (std::out_of_range& e) {
40474       {
40475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40476       };
40477     } catch (std::exception& e) {
40478       {
40479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40480       };
40481     } catch (Dali::DaliException e) {
40482       {
40483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40484       };
40485     } catch (...) {
40486       {
40487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40488       };
40489     }
40490   }
40491
40492 }
40493
40494
40495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
40496   void * jresult ;
40497   Dali::PanGesture *result = 0 ;
40498
40499   {
40500     try {
40501       result = (Dali::PanGesture *)new Dali::PanGesture();
40502     } catch (std::out_of_range& e) {
40503       {
40504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40505       };
40506     } catch (std::exception& e) {
40507       {
40508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40509       };
40510     } catch (Dali::DaliException e) {
40511       {
40512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40513       };
40514     } catch (...) {
40515       {
40516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40517       };
40518     }
40519   }
40520
40521   jresult = (void *)result;
40522   return jresult;
40523 }
40524
40525
40526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
40527   void * jresult ;
40528   Dali::Gesture::State arg1 ;
40529   Dali::PanGesture *result = 0 ;
40530
40531   arg1 = (Dali::Gesture::State)jarg1;
40532   {
40533     try {
40534       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
40535     } catch (std::out_of_range& e) {
40536       {
40537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40538       };
40539     } catch (std::exception& e) {
40540       {
40541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40542       };
40543     } catch (Dali::DaliException e) {
40544       {
40545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40546       };
40547     } catch (...) {
40548       {
40549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40550       };
40551     }
40552   }
40553
40554   jresult = (void *)result;
40555   return jresult;
40556 }
40557
40558
40559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
40560   void * jresult ;
40561   Dali::PanGesture *arg1 = 0 ;
40562   Dali::PanGesture *result = 0 ;
40563
40564   arg1 = (Dali::PanGesture *)jarg1;
40565   if (!arg1) {
40566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40567     return 0;
40568   }
40569   {
40570     try {
40571       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
40572     } catch (std::out_of_range& e) {
40573       {
40574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40575       };
40576     } catch (std::exception& e) {
40577       {
40578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40579       };
40580     } catch (Dali::DaliException e) {
40581       {
40582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40583       };
40584     } catch (...) {
40585       {
40586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40587       };
40588     }
40589   }
40590
40591   jresult = (void *)result;
40592   return jresult;
40593 }
40594
40595
40596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
40597   void * jresult ;
40598   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40599   Dali::PanGesture *arg2 = 0 ;
40600   Dali::PanGesture *result = 0 ;
40601
40602   arg1 = (Dali::PanGesture *)jarg1;
40603   arg2 = (Dali::PanGesture *)jarg2;
40604   if (!arg2) {
40605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40606     return 0;
40607   }
40608   {
40609     try {
40610       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
40611     } catch (std::out_of_range& e) {
40612       {
40613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40614       };
40615     } catch (std::exception& e) {
40616       {
40617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40618       };
40619     } catch (Dali::DaliException e) {
40620       {
40621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40622       };
40623     } catch (...) {
40624       {
40625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40626       };
40627     }
40628   }
40629
40630   jresult = (void *)result;
40631   return jresult;
40632 }
40633
40634
40635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
40636   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40637
40638   arg1 = (Dali::PanGesture *)jarg1;
40639   {
40640     try {
40641       delete arg1;
40642     } catch (std::out_of_range& e) {
40643       {
40644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40645       };
40646     } catch (std::exception& e) {
40647       {
40648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40649       };
40650     } catch (Dali::DaliException e) {
40651       {
40652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40653       };
40654     } catch (...) {
40655       {
40656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40657       };
40658     }
40659   }
40660
40661 }
40662
40663
40664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
40665   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40666   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40667
40668   arg1 = (Dali::PanGesture *)jarg1;
40669   arg2 = (Dali::Vector2 *)jarg2;
40670   if (arg1) (arg1)->velocity = *arg2;
40671 }
40672
40673
40674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
40675   void * jresult ;
40676   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40677   Dali::Vector2 *result = 0 ;
40678
40679   arg1 = (Dali::PanGesture *)jarg1;
40680   result = (Dali::Vector2 *)& ((arg1)->velocity);
40681   jresult = (void *)result;
40682   return jresult;
40683 }
40684
40685
40686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
40687   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40688   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40689
40690   arg1 = (Dali::PanGesture *)jarg1;
40691   arg2 = (Dali::Vector2 *)jarg2;
40692   if (arg1) (arg1)->displacement = *arg2;
40693 }
40694
40695
40696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
40697   void * jresult ;
40698   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40699   Dali::Vector2 *result = 0 ;
40700
40701   arg1 = (Dali::PanGesture *)jarg1;
40702   result = (Dali::Vector2 *)& ((arg1)->displacement);
40703   jresult = (void *)result;
40704   return jresult;
40705 }
40706
40707
40708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
40709   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40710   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40711
40712   arg1 = (Dali::PanGesture *)jarg1;
40713   arg2 = (Dali::Vector2 *)jarg2;
40714   if (arg1) (arg1)->position = *arg2;
40715 }
40716
40717
40718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
40719   void * jresult ;
40720   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40721   Dali::Vector2 *result = 0 ;
40722
40723   arg1 = (Dali::PanGesture *)jarg1;
40724   result = (Dali::Vector2 *)& ((arg1)->position);
40725   jresult = (void *)result;
40726   return jresult;
40727 }
40728
40729
40730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
40731   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40732   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40733
40734   arg1 = (Dali::PanGesture *)jarg1;
40735   arg2 = (Dali::Vector2 *)jarg2;
40736   if (arg1) (arg1)->screenVelocity = *arg2;
40737 }
40738
40739
40740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
40741   void * jresult ;
40742   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40743   Dali::Vector2 *result = 0 ;
40744
40745   arg1 = (Dali::PanGesture *)jarg1;
40746   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
40747   jresult = (void *)result;
40748   return jresult;
40749 }
40750
40751
40752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
40753   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40754   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40755
40756   arg1 = (Dali::PanGesture *)jarg1;
40757   arg2 = (Dali::Vector2 *)jarg2;
40758   if (arg1) (arg1)->screenDisplacement = *arg2;
40759 }
40760
40761
40762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
40763   void * jresult ;
40764   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40765   Dali::Vector2 *result = 0 ;
40766
40767   arg1 = (Dali::PanGesture *)jarg1;
40768   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
40769   jresult = (void *)result;
40770   return jresult;
40771 }
40772
40773
40774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
40775   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40776   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40777
40778   arg1 = (Dali::PanGesture *)jarg1;
40779   arg2 = (Dali::Vector2 *)jarg2;
40780   if (arg1) (arg1)->screenPosition = *arg2;
40781 }
40782
40783
40784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
40785   void * jresult ;
40786   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40787   Dali::Vector2 *result = 0 ;
40788
40789   arg1 = (Dali::PanGesture *)jarg1;
40790   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
40791   jresult = (void *)result;
40792   return jresult;
40793 }
40794
40795
40796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
40797   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40798   unsigned int arg2 ;
40799
40800   arg1 = (Dali::PanGesture *)jarg1;
40801   arg2 = (unsigned int)jarg2;
40802   if (arg1) (arg1)->numberOfTouches = arg2;
40803 }
40804
40805
40806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
40807   unsigned int jresult ;
40808   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40809   unsigned int result;
40810
40811   arg1 = (Dali::PanGesture *)jarg1;
40812   result = (unsigned int) ((arg1)->numberOfTouches);
40813   jresult = result;
40814   return jresult;
40815 }
40816
40817
40818 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
40819   float jresult ;
40820   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40821   float result;
40822
40823   arg1 = (Dali::PanGesture *)jarg1;
40824   {
40825     try {
40826       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
40827     } catch (std::out_of_range& e) {
40828       {
40829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40830       };
40831     } catch (std::exception& e) {
40832       {
40833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40834       };
40835     } catch (Dali::DaliException e) {
40836       {
40837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40838       };
40839     } catch (...) {
40840       {
40841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40842       };
40843     }
40844   }
40845
40846   jresult = result;
40847   return jresult;
40848 }
40849
40850
40851 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
40852   float jresult ;
40853   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40854   float result;
40855
40856   arg1 = (Dali::PanGesture *)jarg1;
40857   {
40858     try {
40859       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
40860     } catch (std::out_of_range& e) {
40861       {
40862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40863       };
40864     } catch (std::exception& e) {
40865       {
40866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40867       };
40868     } catch (Dali::DaliException e) {
40869       {
40870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40871       };
40872     } catch (...) {
40873       {
40874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40875       };
40876     }
40877   }
40878
40879   jresult = result;
40880   return jresult;
40881 }
40882
40883
40884 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
40885   float jresult ;
40886   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40887   float result;
40888
40889   arg1 = (Dali::PanGesture *)jarg1;
40890   {
40891     try {
40892       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
40893     } catch (std::out_of_range& e) {
40894       {
40895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40896       };
40897     } catch (std::exception& e) {
40898       {
40899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40900       };
40901     } catch (Dali::DaliException e) {
40902       {
40903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40904       };
40905     } catch (...) {
40906       {
40907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40908       };
40909     }
40910   }
40911
40912   jresult = result;
40913   return jresult;
40914 }
40915
40916
40917 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
40918   float jresult ;
40919   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40920   float result;
40921
40922   arg1 = (Dali::PanGesture *)jarg1;
40923   {
40924     try {
40925       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
40926     } catch (std::out_of_range& e) {
40927       {
40928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40929       };
40930     } catch (std::exception& e) {
40931       {
40932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40933       };
40934     } catch (Dali::DaliException e) {
40935       {
40936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40937       };
40938     } catch (...) {
40939       {
40940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40941       };
40942     }
40943   }
40944
40945   jresult = result;
40946   return jresult;
40947 }
40948
40949
40950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
40951   void * jresult ;
40952   Dali::PinchGestureDetector *result = 0 ;
40953
40954   {
40955     try {
40956       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
40957     } catch (std::out_of_range& e) {
40958       {
40959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40960       };
40961     } catch (std::exception& e) {
40962       {
40963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40964       };
40965     } catch (Dali::DaliException e) {
40966       {
40967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40968       };
40969     } catch (...) {
40970       {
40971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40972       };
40973     }
40974   }
40975
40976   jresult = (void *)result;
40977   return jresult;
40978 }
40979
40980
40981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
40982   void * jresult ;
40983   Dali::PinchGestureDetector result;
40984
40985   {
40986     try {
40987       result = Dali::PinchGestureDetector::New();
40988     } catch (std::out_of_range& e) {
40989       {
40990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40991       };
40992     } catch (std::exception& e) {
40993       {
40994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40995       };
40996     } catch (Dali::DaliException e) {
40997       {
40998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40999       };
41000     } catch (...) {
41001       {
41002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41003       };
41004     }
41005   }
41006
41007   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41008   return jresult;
41009 }
41010
41011
41012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41013   void * jresult ;
41014   Dali::BaseHandle arg1 ;
41015   Dali::BaseHandle *argp1 ;
41016   Dali::PinchGestureDetector result;
41017
41018   argp1 = (Dali::BaseHandle *)jarg1;
41019   if (!argp1) {
41020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41021     return 0;
41022   }
41023   arg1 = *argp1;
41024   {
41025     try {
41026       result = Dali::PinchGestureDetector::DownCast(arg1);
41027     } catch (std::out_of_range& e) {
41028       {
41029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41030       };
41031     } catch (std::exception& e) {
41032       {
41033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41034       };
41035     } catch (Dali::DaliException e) {
41036       {
41037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41038       };
41039     } catch (...) {
41040       {
41041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41042       };
41043     }
41044   }
41045
41046   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41047   return jresult;
41048 }
41049
41050
41051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41052   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41053
41054   arg1 = (Dali::PinchGestureDetector *)jarg1;
41055   {
41056     try {
41057       delete arg1;
41058     } catch (std::out_of_range& e) {
41059       {
41060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41061       };
41062     } catch (std::exception& e) {
41063       {
41064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41065       };
41066     } catch (Dali::DaliException e) {
41067       {
41068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41069       };
41070     } catch (...) {
41071       {
41072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41073       };
41074     }
41075   }
41076
41077 }
41078
41079
41080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41081   void * jresult ;
41082   Dali::PinchGestureDetector *arg1 = 0 ;
41083   Dali::PinchGestureDetector *result = 0 ;
41084
41085   arg1 = (Dali::PinchGestureDetector *)jarg1;
41086   if (!arg1) {
41087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41088     return 0;
41089   }
41090   {
41091     try {
41092       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41093     } catch (std::out_of_range& e) {
41094       {
41095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41096       };
41097     } catch (std::exception& e) {
41098       {
41099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41100       };
41101     } catch (Dali::DaliException e) {
41102       {
41103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41104       };
41105     } catch (...) {
41106       {
41107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41108       };
41109     }
41110   }
41111
41112   jresult = (void *)result;
41113   return jresult;
41114 }
41115
41116
41117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41118   void * jresult ;
41119   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41120   Dali::PinchGestureDetector *arg2 = 0 ;
41121   Dali::PinchGestureDetector *result = 0 ;
41122
41123   arg1 = (Dali::PinchGestureDetector *)jarg1;
41124   arg2 = (Dali::PinchGestureDetector *)jarg2;
41125   if (!arg2) {
41126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41127     return 0;
41128   }
41129   {
41130     try {
41131       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41132     } catch (std::out_of_range& e) {
41133       {
41134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41135       };
41136     } catch (std::exception& e) {
41137       {
41138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41139       };
41140     } catch (Dali::DaliException e) {
41141       {
41142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41143       };
41144     } catch (...) {
41145       {
41146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41147       };
41148     }
41149   }
41150
41151   jresult = (void *)result;
41152   return jresult;
41153 }
41154
41155
41156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41157   void * jresult ;
41158   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41159   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41160
41161   arg1 = (Dali::PinchGestureDetector *)jarg1;
41162   {
41163     try {
41164       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41165     } catch (std::out_of_range& e) {
41166       {
41167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41168       };
41169     } catch (std::exception& e) {
41170       {
41171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41172       };
41173     } catch (Dali::DaliException e) {
41174       {
41175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41176       };
41177     } catch (...) {
41178       {
41179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41180       };
41181     }
41182   }
41183
41184   jresult = (void *)result;
41185   return jresult;
41186 }
41187
41188
41189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41190   void * jresult ;
41191   Dali::Gesture::State arg1 ;
41192   Dali::PinchGesture *result = 0 ;
41193
41194   arg1 = (Dali::Gesture::State)jarg1;
41195   {
41196     try {
41197       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41198     } catch (std::out_of_range& e) {
41199       {
41200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41201       };
41202     } catch (std::exception& e) {
41203       {
41204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41205       };
41206     } catch (Dali::DaliException e) {
41207       {
41208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41209       };
41210     } catch (...) {
41211       {
41212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41213       };
41214     }
41215   }
41216
41217   jresult = (void *)result;
41218   return jresult;
41219 }
41220
41221
41222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41223   void * jresult ;
41224   Dali::PinchGesture *arg1 = 0 ;
41225   Dali::PinchGesture *result = 0 ;
41226
41227   arg1 = (Dali::PinchGesture *)jarg1;
41228   if (!arg1) {
41229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41230     return 0;
41231   }
41232   {
41233     try {
41234       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
41235     } catch (std::out_of_range& e) {
41236       {
41237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41238       };
41239     } catch (std::exception& e) {
41240       {
41241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41242       };
41243     } catch (Dali::DaliException e) {
41244       {
41245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41246       };
41247     } catch (...) {
41248       {
41249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41250       };
41251     }
41252   }
41253
41254   jresult = (void *)result;
41255   return jresult;
41256 }
41257
41258
41259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
41260   void * jresult ;
41261   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41262   Dali::PinchGesture *arg2 = 0 ;
41263   Dali::PinchGesture *result = 0 ;
41264
41265   arg1 = (Dali::PinchGesture *)jarg1;
41266   arg2 = (Dali::PinchGesture *)jarg2;
41267   if (!arg2) {
41268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41269     return 0;
41270   }
41271   {
41272     try {
41273       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
41274     } catch (std::out_of_range& e) {
41275       {
41276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41277       };
41278     } catch (std::exception& e) {
41279       {
41280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41281       };
41282     } catch (Dali::DaliException e) {
41283       {
41284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41285       };
41286     } catch (...) {
41287       {
41288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41289       };
41290     }
41291   }
41292
41293   jresult = (void *)result;
41294   return jresult;
41295 }
41296
41297
41298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
41299   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41300
41301   arg1 = (Dali::PinchGesture *)jarg1;
41302   {
41303     try {
41304       delete arg1;
41305     } catch (std::out_of_range& e) {
41306       {
41307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41308       };
41309     } catch (std::exception& e) {
41310       {
41311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41312       };
41313     } catch (Dali::DaliException e) {
41314       {
41315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41316       };
41317     } catch (...) {
41318       {
41319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41320       };
41321     }
41322   }
41323
41324 }
41325
41326
41327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
41328   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41329   float arg2 ;
41330
41331   arg1 = (Dali::PinchGesture *)jarg1;
41332   arg2 = (float)jarg2;
41333   if (arg1) (arg1)->scale = arg2;
41334 }
41335
41336
41337 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
41338   float jresult ;
41339   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41340   float result;
41341
41342   arg1 = (Dali::PinchGesture *)jarg1;
41343   result = (float) ((arg1)->scale);
41344   jresult = result;
41345   return jresult;
41346 }
41347
41348
41349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
41350   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41351   float arg2 ;
41352
41353   arg1 = (Dali::PinchGesture *)jarg1;
41354   arg2 = (float)jarg2;
41355   if (arg1) (arg1)->speed = arg2;
41356 }
41357
41358
41359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
41360   float jresult ;
41361   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41362   float result;
41363
41364   arg1 = (Dali::PinchGesture *)jarg1;
41365   result = (float) ((arg1)->speed);
41366   jresult = result;
41367   return jresult;
41368 }
41369
41370
41371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
41372   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41373   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41374
41375   arg1 = (Dali::PinchGesture *)jarg1;
41376   arg2 = (Dali::Vector2 *)jarg2;
41377   if (arg1) (arg1)->screenCenterPoint = *arg2;
41378 }
41379
41380
41381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
41382   void * jresult ;
41383   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41384   Dali::Vector2 *result = 0 ;
41385
41386   arg1 = (Dali::PinchGesture *)jarg1;
41387   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
41388   jresult = (void *)result;
41389   return jresult;
41390 }
41391
41392
41393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
41394   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41395   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41396
41397   arg1 = (Dali::PinchGesture *)jarg1;
41398   arg2 = (Dali::Vector2 *)jarg2;
41399   if (arg1) (arg1)->localCenterPoint = *arg2;
41400 }
41401
41402
41403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
41404   void * jresult ;
41405   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41406   Dali::Vector2 *result = 0 ;
41407
41408   arg1 = (Dali::PinchGesture *)jarg1;
41409   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
41410   jresult = (void *)result;
41411   return jresult;
41412 }
41413
41414
41415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
41416   void * jresult ;
41417   Dali::TapGestureDetector *result = 0 ;
41418
41419   {
41420     try {
41421       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
41422     } catch (std::out_of_range& e) {
41423       {
41424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41425       };
41426     } catch (std::exception& e) {
41427       {
41428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41429       };
41430     } catch (Dali::DaliException e) {
41431       {
41432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41433       };
41434     } catch (...) {
41435       {
41436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41437       };
41438     }
41439   }
41440
41441   jresult = (void *)result;
41442   return jresult;
41443 }
41444
41445
41446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
41447   void * jresult ;
41448   Dali::TapGestureDetector result;
41449
41450   {
41451     try {
41452       result = Dali::TapGestureDetector::New();
41453     } catch (std::out_of_range& e) {
41454       {
41455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41456       };
41457     } catch (std::exception& e) {
41458       {
41459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41460       };
41461     } catch (Dali::DaliException e) {
41462       {
41463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41464       };
41465     } catch (...) {
41466       {
41467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41468       };
41469     }
41470   }
41471
41472   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41473   return jresult;
41474 }
41475
41476
41477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
41478   void * jresult ;
41479   unsigned int arg1 ;
41480   Dali::TapGestureDetector result;
41481
41482   arg1 = (unsigned int)jarg1;
41483   {
41484     try {
41485       result = Dali::TapGestureDetector::New(arg1);
41486     } catch (std::out_of_range& e) {
41487       {
41488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41489       };
41490     } catch (std::exception& e) {
41491       {
41492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41493       };
41494     } catch (Dali::DaliException e) {
41495       {
41496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41497       };
41498     } catch (...) {
41499       {
41500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41501       };
41502     }
41503   }
41504
41505   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41506   return jresult;
41507 }
41508
41509
41510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
41511   void * jresult ;
41512   Dali::BaseHandle arg1 ;
41513   Dali::BaseHandle *argp1 ;
41514   Dali::TapGestureDetector result;
41515
41516   argp1 = (Dali::BaseHandle *)jarg1;
41517   if (!argp1) {
41518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41519     return 0;
41520   }
41521   arg1 = *argp1;
41522   {
41523     try {
41524       result = Dali::TapGestureDetector::DownCast(arg1);
41525     } catch (std::out_of_range& e) {
41526       {
41527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41528       };
41529     } catch (std::exception& e) {
41530       {
41531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41532       };
41533     } catch (Dali::DaliException e) {
41534       {
41535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41536       };
41537     } catch (...) {
41538       {
41539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41540       };
41541     }
41542   }
41543
41544   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41545   return jresult;
41546 }
41547
41548
41549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
41550   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41551
41552   arg1 = (Dali::TapGestureDetector *)jarg1;
41553   {
41554     try {
41555       delete arg1;
41556     } catch (std::out_of_range& e) {
41557       {
41558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41559       };
41560     } catch (std::exception& e) {
41561       {
41562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41563       };
41564     } catch (Dali::DaliException e) {
41565       {
41566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41567       };
41568     } catch (...) {
41569       {
41570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41571       };
41572     }
41573   }
41574
41575 }
41576
41577
41578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
41579   void * jresult ;
41580   Dali::TapGestureDetector *arg1 = 0 ;
41581   Dali::TapGestureDetector *result = 0 ;
41582
41583   arg1 = (Dali::TapGestureDetector *)jarg1;
41584   if (!arg1) {
41585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
41586     return 0;
41587   }
41588   {
41589     try {
41590       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
41591     } catch (std::out_of_range& e) {
41592       {
41593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41594       };
41595     } catch (std::exception& e) {
41596       {
41597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41598       };
41599     } catch (Dali::DaliException e) {
41600       {
41601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41602       };
41603     } catch (...) {
41604       {
41605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41606       };
41607     }
41608   }
41609
41610   jresult = (void *)result;
41611   return jresult;
41612 }
41613
41614
41615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
41616   void * jresult ;
41617   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41618   Dali::TapGestureDetector *arg2 = 0 ;
41619   Dali::TapGestureDetector *result = 0 ;
41620
41621   arg1 = (Dali::TapGestureDetector *)jarg1;
41622   arg2 = (Dali::TapGestureDetector *)jarg2;
41623   if (!arg2) {
41624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
41625     return 0;
41626   }
41627   {
41628     try {
41629       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
41630     } catch (std::out_of_range& e) {
41631       {
41632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41633       };
41634     } catch (std::exception& e) {
41635       {
41636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41637       };
41638     } catch (Dali::DaliException e) {
41639       {
41640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41641       };
41642     } catch (...) {
41643       {
41644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41645       };
41646     }
41647   }
41648
41649   jresult = (void *)result;
41650   return jresult;
41651 }
41652
41653
41654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
41655   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41656   unsigned int arg2 ;
41657
41658   arg1 = (Dali::TapGestureDetector *)jarg1;
41659   arg2 = (unsigned int)jarg2;
41660   {
41661     try {
41662       (arg1)->SetMinimumTapsRequired(arg2);
41663     } catch (std::out_of_range& e) {
41664       {
41665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41666       };
41667     } catch (std::exception& e) {
41668       {
41669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41670       };
41671     } catch (Dali::DaliException e) {
41672       {
41673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41674       };
41675     } catch (...) {
41676       {
41677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41678       };
41679     }
41680   }
41681
41682 }
41683
41684
41685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
41686   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41687   unsigned int arg2 ;
41688
41689   arg1 = (Dali::TapGestureDetector *)jarg1;
41690   arg2 = (unsigned int)jarg2;
41691   {
41692     try {
41693       (arg1)->SetMaximumTapsRequired(arg2);
41694     } catch (std::out_of_range& e) {
41695       {
41696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41697       };
41698     } catch (std::exception& e) {
41699       {
41700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41701       };
41702     } catch (Dali::DaliException e) {
41703       {
41704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41705       };
41706     } catch (...) {
41707       {
41708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41709       };
41710     }
41711   }
41712
41713 }
41714
41715
41716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
41717   unsigned int jresult ;
41718   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41719   unsigned int result;
41720
41721   arg1 = (Dali::TapGestureDetector *)jarg1;
41722   {
41723     try {
41724       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
41725     } catch (std::out_of_range& e) {
41726       {
41727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41728       };
41729     } catch (std::exception& e) {
41730       {
41731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41732       };
41733     } catch (Dali::DaliException e) {
41734       {
41735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41736       };
41737     } catch (...) {
41738       {
41739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41740       };
41741     }
41742   }
41743
41744   jresult = result;
41745   return jresult;
41746 }
41747
41748
41749 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
41750   unsigned int jresult ;
41751   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41752   unsigned int result;
41753
41754   arg1 = (Dali::TapGestureDetector *)jarg1;
41755   {
41756     try {
41757       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
41758     } catch (std::out_of_range& e) {
41759       {
41760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41761       };
41762     } catch (std::exception& e) {
41763       {
41764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41765       };
41766     } catch (Dali::DaliException e) {
41767       {
41768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41769       };
41770     } catch (...) {
41771       {
41772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41773       };
41774     }
41775   }
41776
41777   jresult = result;
41778   return jresult;
41779 }
41780
41781
41782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
41783   void * jresult ;
41784   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41785   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
41786
41787   arg1 = (Dali::TapGestureDetector *)jarg1;
41788   {
41789     try {
41790       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41791     } catch (std::out_of_range& e) {
41792       {
41793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41794       };
41795     } catch (std::exception& e) {
41796       {
41797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41798       };
41799     } catch (Dali::DaliException e) {
41800       {
41801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41802       };
41803     } catch (...) {
41804       {
41805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41806       };
41807     }
41808   }
41809
41810   jresult = (void *)result;
41811   return jresult;
41812 }
41813
41814
41815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
41816   void * jresult ;
41817   Dali::TapGesture *result = 0 ;
41818
41819   {
41820     try {
41821       result = (Dali::TapGesture *)new Dali::TapGesture();
41822     } catch (std::out_of_range& e) {
41823       {
41824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41825       };
41826     } catch (std::exception& e) {
41827       {
41828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41829       };
41830     } catch (Dali::DaliException e) {
41831       {
41832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41833       };
41834     } catch (...) {
41835       {
41836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41837       };
41838     }
41839   }
41840
41841   jresult = (void *)result;
41842   return jresult;
41843 }
41844
41845
41846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
41847   void * jresult ;
41848   Dali::TapGesture *arg1 = 0 ;
41849   Dali::TapGesture *result = 0 ;
41850
41851   arg1 = (Dali::TapGesture *)jarg1;
41852   if (!arg1) {
41853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
41854     return 0;
41855   }
41856   {
41857     try {
41858       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
41859     } catch (std::out_of_range& e) {
41860       {
41861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41862       };
41863     } catch (std::exception& e) {
41864       {
41865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41866       };
41867     } catch (Dali::DaliException e) {
41868       {
41869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41870       };
41871     } catch (...) {
41872       {
41873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41874       };
41875     }
41876   }
41877
41878   jresult = (void *)result;
41879   return jresult;
41880 }
41881
41882
41883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
41884   void * jresult ;
41885   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
41886   Dali::TapGesture *arg2 = 0 ;
41887   Dali::TapGesture *result = 0 ;
41888
41889   arg1 = (Dali::TapGesture *)jarg1;
41890   arg2 = (Dali::TapGesture *)jarg2;
41891   if (!arg2) {
41892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
41893     return 0;
41894   }
41895   {
41896     try {
41897       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
41898     } catch (std::out_of_range& e) {
41899       {
41900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41901       };
41902     } catch (std::exception& e) {
41903       {
41904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41905       };
41906     } catch (Dali::DaliException e) {
41907       {
41908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41909       };
41910     } catch (...) {
41911       {
41912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41913       };
41914     }
41915   }
41916
41917   jresult = (void *)result;
41918   return jresult;
41919 }
41920
41921
41922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
41923   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
41924
41925   arg1 = (Dali::TapGesture *)jarg1;
41926   {
41927     try {
41928       delete arg1;
41929     } catch (std::out_of_range& e) {
41930       {
41931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41932       };
41933     } catch (std::exception& e) {
41934       {
41935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41936       };
41937     } catch (Dali::DaliException e) {
41938       {
41939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41940       };
41941     } catch (...) {
41942       {
41943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41944       };
41945     }
41946   }
41947
41948 }
41949
41950
41951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
41952   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
41953   unsigned int arg2 ;
41954
41955   arg1 = (Dali::TapGesture *)jarg1;
41956   arg2 = (unsigned int)jarg2;
41957   if (arg1) (arg1)->numberOfTaps = arg2;
41958 }
41959
41960
41961 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
41962   unsigned int jresult ;
41963   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
41964   unsigned int result;
41965
41966   arg1 = (Dali::TapGesture *)jarg1;
41967   result = (unsigned int) ((arg1)->numberOfTaps);
41968   jresult = result;
41969   return jresult;
41970 }
41971
41972
41973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41974   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
41975   unsigned int arg2 ;
41976
41977   arg1 = (Dali::TapGesture *)jarg1;
41978   arg2 = (unsigned int)jarg2;
41979   if (arg1) (arg1)->numberOfTouches = arg2;
41980 }
41981
41982
41983 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
41984   unsigned int jresult ;
41985   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
41986   unsigned int result;
41987
41988   arg1 = (Dali::TapGesture *)jarg1;
41989   result = (unsigned int) ((arg1)->numberOfTouches);
41990   jresult = result;
41991   return jresult;
41992 }
41993
41994
41995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
41996   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
41997   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41998
41999   arg1 = (Dali::TapGesture *)jarg1;
42000   arg2 = (Dali::Vector2 *)jarg2;
42001   if (arg1) (arg1)->screenPoint = *arg2;
42002 }
42003
42004
42005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42006   void * jresult ;
42007   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42008   Dali::Vector2 *result = 0 ;
42009
42010   arg1 = (Dali::TapGesture *)jarg1;
42011   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42012   jresult = (void *)result;
42013   return jresult;
42014 }
42015
42016
42017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42018   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42019   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42020
42021   arg1 = (Dali::TapGesture *)jarg1;
42022   arg2 = (Dali::Vector2 *)jarg2;
42023   if (arg1) (arg1)->localPoint = *arg2;
42024 }
42025
42026
42027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42028   void * jresult ;
42029   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42030   Dali::Vector2 *result = 0 ;
42031
42032   arg1 = (Dali::TapGesture *)jarg1;
42033   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42034   jresult = (void *)result;
42035   return jresult;
42036 }
42037
42038
42039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42040   void * jresult ;
42041   Dali::AlphaFunction *result = 0 ;
42042
42043   {
42044     try {
42045       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42046     } catch (std::out_of_range& e) {
42047       {
42048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42049       };
42050     } catch (std::exception& e) {
42051       {
42052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42053       };
42054     } catch (Dali::DaliException e) {
42055       {
42056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42057       };
42058     } catch (...) {
42059       {
42060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42061       };
42062     }
42063   }
42064
42065   jresult = (void *)result;
42066   return jresult;
42067 }
42068
42069
42070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42071   void * jresult ;
42072   Dali::AlphaFunction::BuiltinFunction arg1 ;
42073   Dali::AlphaFunction *result = 0 ;
42074
42075   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42076   {
42077     try {
42078       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42079     } catch (std::out_of_range& e) {
42080       {
42081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42082       };
42083     } catch (std::exception& e) {
42084       {
42085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42086       };
42087     } catch (Dali::DaliException e) {
42088       {
42089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42090       };
42091     } catch (...) {
42092       {
42093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42094       };
42095     }
42096   }
42097
42098   jresult = (void *)result;
42099   return jresult;
42100 }
42101
42102
42103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42104   void * jresult ;
42105   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42106   Dali::AlphaFunction *result = 0 ;
42107
42108   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42109   {
42110     try {
42111       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42112     } catch (std::out_of_range& e) {
42113       {
42114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42115       };
42116     } catch (std::exception& e) {
42117       {
42118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42119       };
42120     } catch (Dali::DaliException e) {
42121       {
42122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42123       };
42124     } catch (...) {
42125       {
42126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42127       };
42128     }
42129   }
42130
42131   jresult = (void *)result;
42132   return jresult;
42133 }
42134
42135
42136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42137   void * jresult ;
42138   Dali::Vector2 *arg1 = 0 ;
42139   Dali::Vector2 *arg2 = 0 ;
42140   Dali::AlphaFunction *result = 0 ;
42141
42142   arg1 = (Dali::Vector2 *)jarg1;
42143   if (!arg1) {
42144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42145     return 0;
42146   }
42147   arg2 = (Dali::Vector2 *)jarg2;
42148   if (!arg2) {
42149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42150     return 0;
42151   }
42152   {
42153     try {
42154       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42155     } catch (std::out_of_range& e) {
42156       {
42157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42158       };
42159     } catch (std::exception& e) {
42160       {
42161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42162       };
42163     } catch (Dali::DaliException e) {
42164       {
42165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42166       };
42167     } catch (...) {
42168       {
42169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42170       };
42171     }
42172   }
42173
42174   jresult = (void *)result;
42175   return jresult;
42176 }
42177
42178
42179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42180   void * jresult ;
42181   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42182   Dali::Vector4 result;
42183
42184   arg1 = (Dali::AlphaFunction *)jarg1;
42185   {
42186     try {
42187       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42188     } catch (std::out_of_range& e) {
42189       {
42190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42191       };
42192     } catch (std::exception& e) {
42193       {
42194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42195       };
42196     } catch (Dali::DaliException e) {
42197       {
42198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42199       };
42200     } catch (...) {
42201       {
42202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42203       };
42204     }
42205   }
42206
42207   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42208   return jresult;
42209 }
42210
42211
42212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42213   void * jresult ;
42214   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42215   Dali::AlphaFunctionPrototype result;
42216
42217   arg1 = (Dali::AlphaFunction *)jarg1;
42218   {
42219     try {
42220       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42221     } catch (std::out_of_range& e) {
42222       {
42223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42224       };
42225     } catch (std::exception& e) {
42226       {
42227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42228       };
42229     } catch (Dali::DaliException e) {
42230       {
42231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42232       };
42233     } catch (...) {
42234       {
42235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42236       };
42237     }
42238   }
42239
42240   jresult = (void *)result;
42241   return jresult;
42242 }
42243
42244
42245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
42246   int jresult ;
42247   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42248   Dali::AlphaFunction::BuiltinFunction result;
42249
42250   arg1 = (Dali::AlphaFunction *)jarg1;
42251   {
42252     try {
42253       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
42254     } catch (std::out_of_range& e) {
42255       {
42256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42257       };
42258     } catch (std::exception& e) {
42259       {
42260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42261       };
42262     } catch (Dali::DaliException e) {
42263       {
42264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42265       };
42266     } catch (...) {
42267       {
42268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42269       };
42270     }
42271   }
42272
42273   jresult = (int)result;
42274   return jresult;
42275 }
42276
42277
42278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
42279   int jresult ;
42280   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42281   Dali::AlphaFunction::Mode result;
42282
42283   arg1 = (Dali::AlphaFunction *)jarg1;
42284   {
42285     try {
42286       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
42287     } catch (std::out_of_range& e) {
42288       {
42289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42290       };
42291     } catch (std::exception& e) {
42292       {
42293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42294       };
42295     } catch (Dali::DaliException e) {
42296       {
42297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42298       };
42299     } catch (...) {
42300       {
42301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42302       };
42303     }
42304   }
42305
42306   jresult = (int)result;
42307   return jresult;
42308 }
42309
42310
42311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
42312   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42313
42314   arg1 = (Dali::AlphaFunction *)jarg1;
42315   {
42316     try {
42317       delete arg1;
42318     } catch (std::out_of_range& e) {
42319       {
42320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42321       };
42322     } catch (std::exception& e) {
42323       {
42324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42325       };
42326     } catch (Dali::DaliException e) {
42327       {
42328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42329       };
42330     } catch (...) {
42331       {
42332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42333       };
42334     }
42335   }
42336
42337 }
42338
42339
42340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
42341   void * jresult ;
42342   Dali::KeyFrames result;
42343
42344   {
42345     try {
42346       result = Dali::KeyFrames::New();
42347     } catch (std::out_of_range& e) {
42348       {
42349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42350       };
42351     } catch (std::exception& e) {
42352       {
42353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42354       };
42355     } catch (Dali::DaliException e) {
42356       {
42357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42358       };
42359     } catch (...) {
42360       {
42361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42362       };
42363     }
42364   }
42365
42366   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42367   return jresult;
42368 }
42369
42370
42371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
42372   void * jresult ;
42373   Dali::BaseHandle arg1 ;
42374   Dali::BaseHandle *argp1 ;
42375   Dali::KeyFrames result;
42376
42377   argp1 = (Dali::BaseHandle *)jarg1;
42378   if (!argp1) {
42379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42380     return 0;
42381   }
42382   arg1 = *argp1;
42383   {
42384     try {
42385       result = Dali::KeyFrames::DownCast(arg1);
42386     } catch (std::out_of_range& e) {
42387       {
42388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42389       };
42390     } catch (std::exception& e) {
42391       {
42392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42393       };
42394     } catch (Dali::DaliException e) {
42395       {
42396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42397       };
42398     } catch (...) {
42399       {
42400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42401       };
42402     }
42403   }
42404
42405   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42406   return jresult;
42407 }
42408
42409
42410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
42411   void * jresult ;
42412   Dali::KeyFrames *result = 0 ;
42413
42414   {
42415     try {
42416       result = (Dali::KeyFrames *)new Dali::KeyFrames();
42417     } catch (std::out_of_range& e) {
42418       {
42419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42420       };
42421     } catch (std::exception& e) {
42422       {
42423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42424       };
42425     } catch (Dali::DaliException e) {
42426       {
42427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42428       };
42429     } catch (...) {
42430       {
42431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42432       };
42433     }
42434   }
42435
42436   jresult = (void *)result;
42437   return jresult;
42438 }
42439
42440
42441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
42442   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42443
42444   arg1 = (Dali::KeyFrames *)jarg1;
42445   {
42446     try {
42447       delete arg1;
42448     } catch (std::out_of_range& e) {
42449       {
42450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42451       };
42452     } catch (std::exception& e) {
42453       {
42454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42455       };
42456     } catch (Dali::DaliException e) {
42457       {
42458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42459       };
42460     } catch (...) {
42461       {
42462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42463       };
42464     }
42465   }
42466
42467 }
42468
42469
42470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
42471   void * jresult ;
42472   Dali::KeyFrames *arg1 = 0 ;
42473   Dali::KeyFrames *result = 0 ;
42474
42475   arg1 = (Dali::KeyFrames *)jarg1;
42476   if (!arg1) {
42477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
42478     return 0;
42479   }
42480   {
42481     try {
42482       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
42483     } catch (std::out_of_range& e) {
42484       {
42485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42486       };
42487     } catch (std::exception& e) {
42488       {
42489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42490       };
42491     } catch (Dali::DaliException e) {
42492       {
42493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42494       };
42495     } catch (...) {
42496       {
42497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42498       };
42499     }
42500   }
42501
42502   jresult = (void *)result;
42503   return jresult;
42504 }
42505
42506
42507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
42508   void * jresult ;
42509   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42510   Dali::KeyFrames *arg2 = 0 ;
42511   Dali::KeyFrames *result = 0 ;
42512
42513   arg1 = (Dali::KeyFrames *)jarg1;
42514   arg2 = (Dali::KeyFrames *)jarg2;
42515   if (!arg2) {
42516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
42517     return 0;
42518   }
42519   {
42520     try {
42521       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
42522     } catch (std::out_of_range& e) {
42523       {
42524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42525       };
42526     } catch (std::exception& e) {
42527       {
42528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42529       };
42530     } catch (Dali::DaliException e) {
42531       {
42532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42533       };
42534     } catch (...) {
42535       {
42536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42537       };
42538     }
42539   }
42540
42541   jresult = (void *)result;
42542   return jresult;
42543 }
42544
42545
42546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
42547   int jresult ;
42548   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42549   Dali::Property::Type result;
42550
42551   arg1 = (Dali::KeyFrames *)jarg1;
42552   {
42553     try {
42554       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
42555     } catch (std::out_of_range& e) {
42556       {
42557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42558       };
42559     } catch (std::exception& e) {
42560       {
42561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42562       };
42563     } catch (Dali::DaliException e) {
42564       {
42565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42566       };
42567     } catch (...) {
42568       {
42569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42570       };
42571     }
42572   }
42573
42574   jresult = (int)result;
42575   return jresult;
42576 }
42577
42578
42579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
42580   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42581   float arg2 ;
42582   Dali::Property::Value arg3 ;
42583   Dali::Property::Value *argp3 ;
42584
42585   arg1 = (Dali::KeyFrames *)jarg1;
42586   arg2 = (float)jarg2;
42587   argp3 = (Dali::Property::Value *)jarg3;
42588   if (!argp3) {
42589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42590     return ;
42591   }
42592   arg3 = *argp3;
42593   {
42594     try {
42595       (arg1)->Add(arg2,arg3);
42596     } catch (std::out_of_range& e) {
42597       {
42598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42599       };
42600     } catch (std::exception& e) {
42601       {
42602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42603       };
42604     } catch (Dali::DaliException e) {
42605       {
42606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42607       };
42608     } catch (...) {
42609       {
42610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42611       };
42612     }
42613   }
42614
42615 }
42616
42617
42618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
42619   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42620   float arg2 ;
42621   Dali::Property::Value arg3 ;
42622   Dali::AlphaFunction arg4 ;
42623   Dali::Property::Value *argp3 ;
42624   Dali::AlphaFunction *argp4 ;
42625
42626   arg1 = (Dali::KeyFrames *)jarg1;
42627   arg2 = (float)jarg2;
42628   argp3 = (Dali::Property::Value *)jarg3;
42629   if (!argp3) {
42630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42631     return ;
42632   }
42633   arg3 = *argp3;
42634   argp4 = (Dali::AlphaFunction *)jarg4;
42635   if (!argp4) {
42636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
42637     return ;
42638   }
42639   arg4 = *argp4;
42640   {
42641     try {
42642       (arg1)->Add(arg2,arg3,arg4);
42643     } catch (std::out_of_range& e) {
42644       {
42645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42646       };
42647     } catch (std::exception& e) {
42648       {
42649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42650       };
42651     } catch (Dali::DaliException e) {
42652       {
42653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42654       };
42655     } catch (...) {
42656       {
42657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42658       };
42659     }
42660   }
42661
42662 }
42663
42664
42665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
42666   int jresult ;
42667   int result;
42668
42669   result = (int)Dali::Path::Property::POINTS;
42670   jresult = (int)result;
42671   return jresult;
42672 }
42673
42674
42675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
42676   int jresult ;
42677   int result;
42678
42679   result = (int)Dali::Path::Property::CONTROL_POINTS;
42680   jresult = (int)result;
42681   return jresult;
42682 }
42683
42684
42685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
42686   void * jresult ;
42687   Dali::Path::Property *result = 0 ;
42688
42689   {
42690     try {
42691       result = (Dali::Path::Property *)new Dali::Path::Property();
42692     } catch (std::out_of_range& e) {
42693       {
42694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42695       };
42696     } catch (std::exception& e) {
42697       {
42698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42699       };
42700     } catch (Dali::DaliException e) {
42701       {
42702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42703       };
42704     } catch (...) {
42705       {
42706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42707       };
42708     }
42709   }
42710
42711   jresult = (void *)result;
42712   return jresult;
42713 }
42714
42715
42716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
42717   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
42718
42719   arg1 = (Dali::Path::Property *)jarg1;
42720   {
42721     try {
42722       delete arg1;
42723     } catch (std::out_of_range& e) {
42724       {
42725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42726       };
42727     } catch (std::exception& e) {
42728       {
42729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42730       };
42731     } catch (Dali::DaliException e) {
42732       {
42733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42734       };
42735     } catch (...) {
42736       {
42737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42738       };
42739     }
42740   }
42741
42742 }
42743
42744
42745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
42746   void * jresult ;
42747   Dali::Path result;
42748
42749   {
42750     try {
42751       result = Dali::Path::New();
42752     } catch (std::out_of_range& e) {
42753       {
42754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42755       };
42756     } catch (std::exception& e) {
42757       {
42758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42759       };
42760     } catch (Dali::DaliException e) {
42761       {
42762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42763       };
42764     } catch (...) {
42765       {
42766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42767       };
42768     }
42769   }
42770
42771   jresult = new Dali::Path((const Dali::Path &)result);
42772   return jresult;
42773 }
42774
42775
42776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
42777   void * jresult ;
42778   Dali::BaseHandle arg1 ;
42779   Dali::BaseHandle *argp1 ;
42780   Dali::Path result;
42781
42782   argp1 = (Dali::BaseHandle *)jarg1;
42783   if (!argp1) {
42784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42785     return 0;
42786   }
42787   arg1 = *argp1;
42788   {
42789     try {
42790       result = Dali::Path::DownCast(arg1);
42791     } catch (std::out_of_range& e) {
42792       {
42793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42794       };
42795     } catch (std::exception& e) {
42796       {
42797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42798       };
42799     } catch (Dali::DaliException e) {
42800       {
42801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42802       };
42803     } catch (...) {
42804       {
42805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42806       };
42807     }
42808   }
42809
42810   jresult = new Dali::Path((const Dali::Path &)result);
42811   return jresult;
42812 }
42813
42814
42815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
42816   void * jresult ;
42817   Dali::Path *result = 0 ;
42818
42819   {
42820     try {
42821       result = (Dali::Path *)new Dali::Path();
42822     } catch (std::out_of_range& e) {
42823       {
42824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42825       };
42826     } catch (std::exception& e) {
42827       {
42828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42829       };
42830     } catch (Dali::DaliException e) {
42831       {
42832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42833       };
42834     } catch (...) {
42835       {
42836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42837       };
42838     }
42839   }
42840
42841   jresult = (void *)result;
42842   return jresult;
42843 }
42844
42845
42846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
42847   Dali::Path *arg1 = (Dali::Path *) 0 ;
42848
42849   arg1 = (Dali::Path *)jarg1;
42850   {
42851     try {
42852       delete arg1;
42853     } catch (std::out_of_range& e) {
42854       {
42855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42856       };
42857     } catch (std::exception& e) {
42858       {
42859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42860       };
42861     } catch (Dali::DaliException e) {
42862       {
42863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42864       };
42865     } catch (...) {
42866       {
42867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42868       };
42869     }
42870   }
42871
42872 }
42873
42874
42875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
42876   void * jresult ;
42877   Dali::Path *arg1 = 0 ;
42878   Dali::Path *result = 0 ;
42879
42880   arg1 = (Dali::Path *)jarg1;
42881   if (!arg1) {
42882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
42883     return 0;
42884   }
42885   {
42886     try {
42887       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
42888     } catch (std::out_of_range& e) {
42889       {
42890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42891       };
42892     } catch (std::exception& e) {
42893       {
42894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42895       };
42896     } catch (Dali::DaliException e) {
42897       {
42898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42899       };
42900     } catch (...) {
42901       {
42902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42903       };
42904     }
42905   }
42906
42907   jresult = (void *)result;
42908   return jresult;
42909 }
42910
42911
42912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
42913   void * jresult ;
42914   Dali::Path *arg1 = (Dali::Path *) 0 ;
42915   Dali::Path *arg2 = 0 ;
42916   Dali::Path *result = 0 ;
42917
42918   arg1 = (Dali::Path *)jarg1;
42919   arg2 = (Dali::Path *)jarg2;
42920   if (!arg2) {
42921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
42922     return 0;
42923   }
42924   {
42925     try {
42926       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
42927     } catch (std::out_of_range& e) {
42928       {
42929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42930       };
42931     } catch (std::exception& e) {
42932       {
42933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42934       };
42935     } catch (Dali::DaliException e) {
42936       {
42937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42938       };
42939     } catch (...) {
42940       {
42941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42942       };
42943     }
42944   }
42945
42946   jresult = (void *)result;
42947   return jresult;
42948 }
42949
42950
42951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
42952   Dali::Path *arg1 = (Dali::Path *) 0 ;
42953   Dali::Vector3 *arg2 = 0 ;
42954
42955   arg1 = (Dali::Path *)jarg1;
42956   arg2 = (Dali::Vector3 *)jarg2;
42957   if (!arg2) {
42958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42959     return ;
42960   }
42961   {
42962     try {
42963       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
42964     } catch (std::out_of_range& e) {
42965       {
42966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42967       };
42968     } catch (std::exception& e) {
42969       {
42970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42971       };
42972     } catch (Dali::DaliException e) {
42973       {
42974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42975       };
42976     } catch (...) {
42977       {
42978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42979       };
42980     }
42981   }
42982
42983 }
42984
42985
42986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
42987   Dali::Path *arg1 = (Dali::Path *) 0 ;
42988   Dali::Vector3 *arg2 = 0 ;
42989
42990   arg1 = (Dali::Path *)jarg1;
42991   arg2 = (Dali::Vector3 *)jarg2;
42992   if (!arg2) {
42993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42994     return ;
42995   }
42996   {
42997     try {
42998       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
42999     } catch (std::out_of_range& e) {
43000       {
43001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43002       };
43003     } catch (std::exception& e) {
43004       {
43005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43006       };
43007     } catch (Dali::DaliException e) {
43008       {
43009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43010       };
43011     } catch (...) {
43012       {
43013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43014       };
43015     }
43016   }
43017
43018 }
43019
43020
43021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43022   Dali::Path *arg1 = (Dali::Path *) 0 ;
43023   float arg2 ;
43024
43025   arg1 = (Dali::Path *)jarg1;
43026   arg2 = (float)jarg2;
43027   {
43028     try {
43029       (arg1)->GenerateControlPoints(arg2);
43030     } catch (std::out_of_range& e) {
43031       {
43032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43033       };
43034     } catch (std::exception& e) {
43035       {
43036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43037       };
43038     } catch (Dali::DaliException e) {
43039       {
43040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43041       };
43042     } catch (...) {
43043       {
43044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43045       };
43046     }
43047   }
43048
43049 }
43050
43051
43052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43053   Dali::Path *arg1 = (Dali::Path *) 0 ;
43054   float arg2 ;
43055   Dali::Vector3 *arg3 = 0 ;
43056   Dali::Vector3 *arg4 = 0 ;
43057
43058   arg1 = (Dali::Path *)jarg1;
43059   arg2 = (float)jarg2;
43060   arg3 = (Dali::Vector3 *)jarg3;
43061   if (!arg3) {
43062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43063     return ;
43064   }
43065   arg4 = (Dali::Vector3 *)jarg4;
43066   if (!arg4) {
43067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43068     return ;
43069   }
43070   {
43071     try {
43072       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43073     } catch (std::out_of_range& e) {
43074       {
43075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43076       };
43077     } catch (std::exception& e) {
43078       {
43079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43080       };
43081     } catch (Dali::DaliException e) {
43082       {
43083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43084       };
43085     } catch (...) {
43086       {
43087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43088       };
43089     }
43090   }
43091
43092 }
43093
43094
43095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43096   void * jresult ;
43097   Dali::Path *arg1 = (Dali::Path *) 0 ;
43098   size_t arg2 ;
43099   Dali::Vector3 *result = 0 ;
43100
43101   arg1 = (Dali::Path *)jarg1;
43102   arg2 = (size_t)jarg2;
43103   {
43104     try {
43105       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43106     } catch (std::out_of_range& e) {
43107       {
43108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43109       };
43110     } catch (std::exception& e) {
43111       {
43112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43113       };
43114     } catch (Dali::DaliException e) {
43115       {
43116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43117       };
43118     } catch (...) {
43119       {
43120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43121       };
43122     }
43123   }
43124
43125   jresult = (void *)result;
43126   return jresult;
43127 }
43128
43129
43130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43131   void * jresult ;
43132   Dali::Path *arg1 = (Dali::Path *) 0 ;
43133   size_t arg2 ;
43134   Dali::Vector3 *result = 0 ;
43135
43136   arg1 = (Dali::Path *)jarg1;
43137   arg2 = (size_t)jarg2;
43138   {
43139     try {
43140       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43141     } catch (std::out_of_range& e) {
43142       {
43143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43144       };
43145     } catch (std::exception& e) {
43146       {
43147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43148       };
43149     } catch (Dali::DaliException e) {
43150       {
43151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43152       };
43153     } catch (...) {
43154       {
43155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43156       };
43157     }
43158   }
43159
43160   jresult = (void *)result;
43161   return jresult;
43162 }
43163
43164
43165 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43166   unsigned long jresult ;
43167   Dali::Path *arg1 = (Dali::Path *) 0 ;
43168   size_t result;
43169
43170   arg1 = (Dali::Path *)jarg1;
43171   {
43172     try {
43173       result = ((Dali::Path const *)arg1)->GetPointCount();
43174     } catch (std::out_of_range& e) {
43175       {
43176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43177       };
43178     } catch (std::exception& e) {
43179       {
43180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43181       };
43182     } catch (Dali::DaliException e) {
43183       {
43184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43185       };
43186     } catch (...) {
43187       {
43188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43189       };
43190     }
43191   }
43192
43193   jresult = (unsigned long)result;
43194   return jresult;
43195 }
43196
43197
43198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43199   void * jresult ;
43200   float arg1 ;
43201   Dali::TimePeriod *result = 0 ;
43202
43203   arg1 = (float)jarg1;
43204   {
43205     try {
43206       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43207     } catch (std::out_of_range& e) {
43208       {
43209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43210       };
43211     } catch (std::exception& e) {
43212       {
43213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43214       };
43215     } catch (Dali::DaliException e) {
43216       {
43217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43218       };
43219     } catch (...) {
43220       {
43221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43222       };
43223     }
43224   }
43225
43226   jresult = (void *)result;
43227   return jresult;
43228 }
43229
43230
43231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43232   void * jresult ;
43233   float arg1 ;
43234   float arg2 ;
43235   Dali::TimePeriod *result = 0 ;
43236
43237   arg1 = (float)jarg1;
43238   arg2 = (float)jarg2;
43239   {
43240     try {
43241       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
43242     } catch (std::out_of_range& e) {
43243       {
43244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43245       };
43246     } catch (std::exception& e) {
43247       {
43248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43249       };
43250     } catch (Dali::DaliException e) {
43251       {
43252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43253       };
43254     } catch (...) {
43255       {
43256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43257       };
43258     }
43259   }
43260
43261   jresult = (void *)result;
43262   return jresult;
43263 }
43264
43265
43266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
43267   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43268
43269   arg1 = (Dali::TimePeriod *)jarg1;
43270   {
43271     try {
43272       delete arg1;
43273     } catch (std::out_of_range& e) {
43274       {
43275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43276       };
43277     } catch (std::exception& e) {
43278       {
43279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43280       };
43281     } catch (Dali::DaliException e) {
43282       {
43283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43284       };
43285     } catch (...) {
43286       {
43287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43288       };
43289     }
43290   }
43291
43292 }
43293
43294
43295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
43296   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43297   float arg2 ;
43298
43299   arg1 = (Dali::TimePeriod *)jarg1;
43300   arg2 = (float)jarg2;
43301   if (arg1) (arg1)->delaySeconds = arg2;
43302 }
43303
43304
43305 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
43306   float jresult ;
43307   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43308   float result;
43309
43310   arg1 = (Dali::TimePeriod *)jarg1;
43311   result = (float) ((arg1)->delaySeconds);
43312   jresult = result;
43313   return jresult;
43314 }
43315
43316
43317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
43318   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43319   float arg2 ;
43320
43321   arg1 = (Dali::TimePeriod *)jarg1;
43322   arg2 = (float)jarg2;
43323   if (arg1) (arg1)->durationSeconds = arg2;
43324 }
43325
43326
43327 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
43328   float jresult ;
43329   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43330   float result;
43331
43332   arg1 = (Dali::TimePeriod *)jarg1;
43333   result = (float) ((arg1)->durationSeconds);
43334   jresult = result;
43335   return jresult;
43336 }
43337
43338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
43339   int jresult ;
43340   int result;
43341
43342   result = (int)Dali::LinearConstrainer::Property::VALUE;
43343   jresult = (int)result;
43344   return jresult;
43345 }
43346
43347
43348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
43349   int jresult ;
43350   int result;
43351
43352   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
43353   jresult = (int)result;
43354   return jresult;
43355 }
43356
43357
43358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
43359   void * jresult ;
43360   Dali::LinearConstrainer::Property *result = 0 ;
43361
43362   {
43363     try {
43364       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
43365     } catch (std::out_of_range& e) {
43366       {
43367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43368       };
43369     } catch (std::exception& e) {
43370       {
43371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43372       };
43373     } catch (Dali::DaliException e) {
43374       {
43375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43376       };
43377     } catch (...) {
43378       {
43379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43380       };
43381     }
43382   }
43383
43384   jresult = (void *)result;
43385   return jresult;
43386 }
43387
43388
43389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
43390   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
43391
43392   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
43393   {
43394     try {
43395       delete arg1;
43396     } catch (std::out_of_range& e) {
43397       {
43398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43399       };
43400     } catch (std::exception& e) {
43401       {
43402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43403       };
43404     } catch (Dali::DaliException e) {
43405       {
43406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43407       };
43408     } catch (...) {
43409       {
43410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43411       };
43412     }
43413   }
43414
43415 }
43416
43417
43418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
43419   void * jresult ;
43420   Dali::LinearConstrainer result;
43421
43422   {
43423     try {
43424       result = Dali::LinearConstrainer::New();
43425     } catch (std::out_of_range& e) {
43426       {
43427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43428       };
43429     } catch (std::exception& e) {
43430       {
43431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43432       };
43433     } catch (Dali::DaliException e) {
43434       {
43435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43436       };
43437     } catch (...) {
43438       {
43439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43440       };
43441     }
43442   }
43443
43444   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
43445   return jresult;
43446 }
43447
43448
43449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
43450   void * jresult ;
43451   Dali::BaseHandle arg1 ;
43452   Dali::BaseHandle *argp1 ;
43453   Dali::LinearConstrainer result;
43454
43455   argp1 = (Dali::BaseHandle *)jarg1;
43456   if (!argp1) {
43457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43458     return 0;
43459   }
43460   arg1 = *argp1;
43461   {
43462     try {
43463       result = Dali::LinearConstrainer::DownCast(arg1);
43464     } catch (std::out_of_range& e) {
43465       {
43466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43467       };
43468     } catch (std::exception& e) {
43469       {
43470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43471       };
43472     } catch (Dali::DaliException e) {
43473       {
43474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43475       };
43476     } catch (...) {
43477       {
43478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43479       };
43480     }
43481   }
43482
43483   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
43484   return jresult;
43485 }
43486
43487
43488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
43489   void * jresult ;
43490   Dali::LinearConstrainer *result = 0 ;
43491
43492   {
43493     try {
43494       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
43495     } catch (std::out_of_range& e) {
43496       {
43497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43498       };
43499     } catch (std::exception& e) {
43500       {
43501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43502       };
43503     } catch (Dali::DaliException e) {
43504       {
43505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43506       };
43507     } catch (...) {
43508       {
43509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43510       };
43511     }
43512   }
43513
43514   jresult = (void *)result;
43515   return jresult;
43516 }
43517
43518
43519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
43520   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43521
43522   arg1 = (Dali::LinearConstrainer *)jarg1;
43523   {
43524     try {
43525       delete arg1;
43526     } catch (std::out_of_range& e) {
43527       {
43528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43529       };
43530     } catch (std::exception& e) {
43531       {
43532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43533       };
43534     } catch (Dali::DaliException e) {
43535       {
43536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43537       };
43538     } catch (...) {
43539       {
43540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43541       };
43542     }
43543   }
43544
43545 }
43546
43547
43548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
43549   void * jresult ;
43550   Dali::LinearConstrainer *arg1 = 0 ;
43551   Dali::LinearConstrainer *result = 0 ;
43552
43553   arg1 = (Dali::LinearConstrainer *)jarg1;
43554   if (!arg1) {
43555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
43556     return 0;
43557   }
43558   {
43559     try {
43560       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
43561     } catch (std::out_of_range& e) {
43562       {
43563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43564       };
43565     } catch (std::exception& e) {
43566       {
43567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43568       };
43569     } catch (Dali::DaliException e) {
43570       {
43571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43572       };
43573     } catch (...) {
43574       {
43575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43576       };
43577     }
43578   }
43579
43580   jresult = (void *)result;
43581   return jresult;
43582 }
43583
43584
43585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
43586   void * jresult ;
43587   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43588   Dali::LinearConstrainer *arg2 = 0 ;
43589   Dali::LinearConstrainer *result = 0 ;
43590
43591   arg1 = (Dali::LinearConstrainer *)jarg1;
43592   arg2 = (Dali::LinearConstrainer *)jarg2;
43593   if (!arg2) {
43594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
43595     return 0;
43596   }
43597   {
43598     try {
43599       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
43600     } catch (std::out_of_range& e) {
43601       {
43602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43603       };
43604     } catch (std::exception& e) {
43605       {
43606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43607       };
43608     } catch (Dali::DaliException e) {
43609       {
43610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43611       };
43612     } catch (...) {
43613       {
43614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43615       };
43616     }
43617   }
43618
43619   jresult = (void *)result;
43620   return jresult;
43621 }
43622
43623
43624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
43625   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43626   SwigValueWrapper< Dali::Property > arg2 ;
43627   SwigValueWrapper< Dali::Property > arg3 ;
43628   Dali::Vector2 *arg4 = 0 ;
43629   Dali::Vector2 *arg5 = 0 ;
43630   Dali::Property *argp2 ;
43631   Dali::Property *argp3 ;
43632
43633   arg1 = (Dali::LinearConstrainer *)jarg1;
43634   argp2 = (Dali::Property *)jarg2;
43635   if (!argp2) {
43636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43637     return ;
43638   }
43639   arg2 = *argp2;
43640   argp3 = (Dali::Property *)jarg3;
43641   if (!argp3) {
43642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43643     return ;
43644   }
43645   arg3 = *argp3;
43646   arg4 = (Dali::Vector2 *)jarg4;
43647   if (!arg4) {
43648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43649     return ;
43650   }
43651   arg5 = (Dali::Vector2 *)jarg5;
43652   if (!arg5) {
43653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43654     return ;
43655   }
43656   {
43657     try {
43658       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
43659     } catch (std::out_of_range& e) {
43660       {
43661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43662       };
43663     } catch (std::exception& e) {
43664       {
43665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43666       };
43667     } catch (Dali::DaliException e) {
43668       {
43669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43670       };
43671     } catch (...) {
43672       {
43673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43674       };
43675     }
43676   }
43677
43678 }
43679
43680
43681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
43682   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43683   SwigValueWrapper< Dali::Property > arg2 ;
43684   SwigValueWrapper< Dali::Property > arg3 ;
43685   Dali::Vector2 *arg4 = 0 ;
43686   Dali::Property *argp2 ;
43687   Dali::Property *argp3 ;
43688
43689   arg1 = (Dali::LinearConstrainer *)jarg1;
43690   argp2 = (Dali::Property *)jarg2;
43691   if (!argp2) {
43692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43693     return ;
43694   }
43695   arg2 = *argp2;
43696   argp3 = (Dali::Property *)jarg3;
43697   if (!argp3) {
43698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43699     return ;
43700   }
43701   arg3 = *argp3;
43702   arg4 = (Dali::Vector2 *)jarg4;
43703   if (!arg4) {
43704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43705     return ;
43706   }
43707   {
43708     try {
43709       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
43710     } catch (std::out_of_range& e) {
43711       {
43712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43713       };
43714     } catch (std::exception& e) {
43715       {
43716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43717       };
43718     } catch (Dali::DaliException e) {
43719       {
43720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43721       };
43722     } catch (...) {
43723       {
43724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43725       };
43726     }
43727   }
43728
43729 }
43730
43731
43732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
43733   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43734   Dali::Handle *arg2 = 0 ;
43735
43736   arg1 = (Dali::LinearConstrainer *)jarg1;
43737   arg2 = (Dali::Handle *)jarg2;
43738   if (!arg2) {
43739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
43740     return ;
43741   }
43742   {
43743     try {
43744       (arg1)->Remove(*arg2);
43745     } catch (std::out_of_range& e) {
43746       {
43747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43748       };
43749     } catch (std::exception& e) {
43750       {
43751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43752       };
43753     } catch (Dali::DaliException e) {
43754       {
43755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43756       };
43757     } catch (...) {
43758       {
43759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43760       };
43761     }
43762   }
43763
43764 }
43765
43766
43767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
43768   int jresult ;
43769   int result;
43770
43771   result = (int)Dali::PathConstrainer::Property::FORWARD;
43772   jresult = (int)result;
43773   return jresult;
43774 }
43775
43776
43777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
43778   int jresult ;
43779   int result;
43780
43781   result = (int)Dali::PathConstrainer::Property::POINTS;
43782   jresult = (int)result;
43783   return jresult;
43784 }
43785
43786
43787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
43788   int jresult ;
43789   int result;
43790
43791   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
43792   jresult = (int)result;
43793   return jresult;
43794 }
43795
43796
43797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
43798   void * jresult ;
43799   Dali::PathConstrainer::Property *result = 0 ;
43800
43801   {
43802     try {
43803       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
43804     } catch (std::out_of_range& e) {
43805       {
43806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43807       };
43808     } catch (std::exception& e) {
43809       {
43810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43811       };
43812     } catch (Dali::DaliException e) {
43813       {
43814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43815       };
43816     } catch (...) {
43817       {
43818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43819       };
43820     }
43821   }
43822
43823   jresult = (void *)result;
43824   return jresult;
43825 }
43826
43827
43828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
43829   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
43830
43831   arg1 = (Dali::PathConstrainer::Property *)jarg1;
43832   {
43833     try {
43834       delete arg1;
43835     } catch (std::out_of_range& e) {
43836       {
43837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43838       };
43839     } catch (std::exception& e) {
43840       {
43841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43842       };
43843     } catch (Dali::DaliException e) {
43844       {
43845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43846       };
43847     } catch (...) {
43848       {
43849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43850       };
43851     }
43852   }
43853
43854 }
43855
43856
43857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
43858   void * jresult ;
43859   Dali::PathConstrainer result;
43860
43861   {
43862     try {
43863       result = Dali::PathConstrainer::New();
43864     } catch (std::out_of_range& e) {
43865       {
43866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43867       };
43868     } catch (std::exception& e) {
43869       {
43870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43871       };
43872     } catch (Dali::DaliException e) {
43873       {
43874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43875       };
43876     } catch (...) {
43877       {
43878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43879       };
43880     }
43881   }
43882
43883   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
43884   return jresult;
43885 }
43886
43887
43888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
43889   void * jresult ;
43890   Dali::BaseHandle arg1 ;
43891   Dali::BaseHandle *argp1 ;
43892   Dali::PathConstrainer result;
43893
43894   argp1 = (Dali::BaseHandle *)jarg1;
43895   if (!argp1) {
43896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43897     return 0;
43898   }
43899   arg1 = *argp1;
43900   {
43901     try {
43902       result = Dali::PathConstrainer::DownCast(arg1);
43903     } catch (std::out_of_range& e) {
43904       {
43905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43906       };
43907     } catch (std::exception& e) {
43908       {
43909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43910       };
43911     } catch (Dali::DaliException e) {
43912       {
43913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43914       };
43915     } catch (...) {
43916       {
43917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43918       };
43919     }
43920   }
43921
43922   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
43923   return jresult;
43924 }
43925
43926
43927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
43928   void * jresult ;
43929   Dali::PathConstrainer *result = 0 ;
43930
43931   {
43932     try {
43933       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
43934     } catch (std::out_of_range& e) {
43935       {
43936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43937       };
43938     } catch (std::exception& e) {
43939       {
43940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43941       };
43942     } catch (Dali::DaliException e) {
43943       {
43944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43945       };
43946     } catch (...) {
43947       {
43948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43949       };
43950     }
43951   }
43952
43953   jresult = (void *)result;
43954   return jresult;
43955 }
43956
43957
43958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
43959   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
43960
43961   arg1 = (Dali::PathConstrainer *)jarg1;
43962   {
43963     try {
43964       delete arg1;
43965     } catch (std::out_of_range& e) {
43966       {
43967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43968       };
43969     } catch (std::exception& e) {
43970       {
43971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43972       };
43973     } catch (Dali::DaliException e) {
43974       {
43975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43976       };
43977     } catch (...) {
43978       {
43979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43980       };
43981     }
43982   }
43983
43984 }
43985
43986
43987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
43988   void * jresult ;
43989   Dali::PathConstrainer *arg1 = 0 ;
43990   Dali::PathConstrainer *result = 0 ;
43991
43992   arg1 = (Dali::PathConstrainer *)jarg1;
43993   if (!arg1) {
43994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
43995     return 0;
43996   }
43997   {
43998     try {
43999       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44000     } catch (std::out_of_range& e) {
44001       {
44002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44003       };
44004     } catch (std::exception& e) {
44005       {
44006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44007       };
44008     } catch (Dali::DaliException e) {
44009       {
44010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44011       };
44012     } catch (...) {
44013       {
44014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44015       };
44016     }
44017   }
44018
44019   jresult = (void *)result;
44020   return jresult;
44021 }
44022
44023
44024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44025   void * jresult ;
44026   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44027   Dali::PathConstrainer *arg2 = 0 ;
44028   Dali::PathConstrainer *result = 0 ;
44029
44030   arg1 = (Dali::PathConstrainer *)jarg1;
44031   arg2 = (Dali::PathConstrainer *)jarg2;
44032   if (!arg2) {
44033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44034     return 0;
44035   }
44036   {
44037     try {
44038       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44039     } catch (std::out_of_range& e) {
44040       {
44041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44042       };
44043     } catch (std::exception& e) {
44044       {
44045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44046       };
44047     } catch (Dali::DaliException e) {
44048       {
44049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44050       };
44051     } catch (...) {
44052       {
44053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44054       };
44055     }
44056   }
44057
44058   jresult = (void *)result;
44059   return jresult;
44060 }
44061
44062
44063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44064   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44065   SwigValueWrapper< Dali::Property > arg2 ;
44066   SwigValueWrapper< Dali::Property > arg3 ;
44067   Dali::Vector2 *arg4 = 0 ;
44068   Dali::Vector2 *arg5 = 0 ;
44069   Dali::Property *argp2 ;
44070   Dali::Property *argp3 ;
44071
44072   arg1 = (Dali::PathConstrainer *)jarg1;
44073   argp2 = (Dali::Property *)jarg2;
44074   if (!argp2) {
44075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44076     return ;
44077   }
44078   arg2 = *argp2;
44079   argp3 = (Dali::Property *)jarg3;
44080   if (!argp3) {
44081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44082     return ;
44083   }
44084   arg3 = *argp3;
44085   arg4 = (Dali::Vector2 *)jarg4;
44086   if (!arg4) {
44087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44088     return ;
44089   }
44090   arg5 = (Dali::Vector2 *)jarg5;
44091   if (!arg5) {
44092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44093     return ;
44094   }
44095   {
44096     try {
44097       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44098     } catch (std::out_of_range& e) {
44099       {
44100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44101       };
44102     } catch (std::exception& e) {
44103       {
44104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44105       };
44106     } catch (Dali::DaliException e) {
44107       {
44108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44109       };
44110     } catch (...) {
44111       {
44112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44113       };
44114     }
44115   }
44116
44117 }
44118
44119
44120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44121   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44122   SwigValueWrapper< Dali::Property > arg2 ;
44123   SwigValueWrapper< Dali::Property > arg3 ;
44124   Dali::Vector2 *arg4 = 0 ;
44125   Dali::Property *argp2 ;
44126   Dali::Property *argp3 ;
44127
44128   arg1 = (Dali::PathConstrainer *)jarg1;
44129   argp2 = (Dali::Property *)jarg2;
44130   if (!argp2) {
44131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44132     return ;
44133   }
44134   arg2 = *argp2;
44135   argp3 = (Dali::Property *)jarg3;
44136   if (!argp3) {
44137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44138     return ;
44139   }
44140   arg3 = *argp3;
44141   arg4 = (Dali::Vector2 *)jarg4;
44142   if (!arg4) {
44143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44144     return ;
44145   }
44146   {
44147     try {
44148       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44149     } catch (std::out_of_range& e) {
44150       {
44151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44152       };
44153     } catch (std::exception& e) {
44154       {
44155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44156       };
44157     } catch (Dali::DaliException e) {
44158       {
44159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44160       };
44161     } catch (...) {
44162       {
44163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44164       };
44165     }
44166   }
44167
44168 }
44169
44170
44171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44172   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44173   Dali::Handle *arg2 = 0 ;
44174
44175   arg1 = (Dali::PathConstrainer *)jarg1;
44176   arg2 = (Dali::Handle *)jarg2;
44177   if (!arg2) {
44178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44179     return ;
44180   }
44181   {
44182     try {
44183       (arg1)->Remove(*arg2);
44184     } catch (std::out_of_range& e) {
44185       {
44186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44187       };
44188     } catch (std::exception& e) {
44189       {
44190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44191       };
44192     } catch (Dali::DaliException e) {
44193       {
44194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44195       };
44196     } catch (...) {
44197       {
44198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44199       };
44200     }
44201   }
44202
44203 }
44204
44205
44206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44207   int jresult ;
44208   Dali::FittingMode::Type result;
44209
44210   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44211   jresult = (int)result;
44212   return jresult;
44213 }
44214
44215
44216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44217   int jresult ;
44218   Dali::SamplingMode::Type result;
44219
44220   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44221   jresult = (int)result;
44222   return jresult;
44223 }
44224
44225
44226 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
44227   unsigned int jresult ;
44228   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44229   bool result;
44230
44231   arg1 = (Dali::NativeImageInterface *)jarg1;
44232   {
44233     try {
44234       result = (bool)(arg1)->CreateResource();
44235     } catch (std::out_of_range& e) {
44236       {
44237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44238       };
44239     } catch (std::exception& e) {
44240       {
44241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44242       };
44243     } catch (Dali::DaliException e) {
44244       {
44245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44246       };
44247     } catch (...) {
44248       {
44249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44250       };
44251     }
44252   }
44253
44254   jresult = result;
44255   return jresult;
44256 }
44257
44258
44259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
44260   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44261
44262   arg1 = (Dali::NativeImageInterface *)jarg1;
44263   {
44264     try {
44265       (arg1)->DestroyResource();
44266     } catch (std::out_of_range& e) {
44267       {
44268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44269       };
44270     } catch (std::exception& e) {
44271       {
44272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44273       };
44274     } catch (Dali::DaliException e) {
44275       {
44276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44277       };
44278     } catch (...) {
44279       {
44280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44281       };
44282     }
44283   }
44284
44285 }
44286
44287
44288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
44289   unsigned int jresult ;
44290   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44291   unsigned int result;
44292
44293   arg1 = (Dali::NativeImageInterface *)jarg1;
44294   {
44295     try {
44296       result = (unsigned int)(arg1)->TargetTexture();
44297     } catch (std::out_of_range& e) {
44298       {
44299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44300       };
44301     } catch (std::exception& e) {
44302       {
44303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44304       };
44305     } catch (Dali::DaliException e) {
44306       {
44307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44308       };
44309     } catch (...) {
44310       {
44311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44312       };
44313     }
44314   }
44315
44316   jresult = result;
44317   return jresult;
44318 }
44319
44320
44321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
44322   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44323
44324   arg1 = (Dali::NativeImageInterface *)jarg1;
44325   {
44326     try {
44327       (arg1)->PrepareTexture();
44328     } catch (std::out_of_range& e) {
44329       {
44330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44331       };
44332     } catch (std::exception& e) {
44333       {
44334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44335       };
44336     } catch (Dali::DaliException e) {
44337       {
44338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44339       };
44340     } catch (...) {
44341       {
44342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44343       };
44344     }
44345   }
44346
44347 }
44348
44349
44350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
44351   unsigned int jresult ;
44352   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44353   unsigned int result;
44354
44355   arg1 = (Dali::NativeImageInterface *)jarg1;
44356   {
44357     try {
44358       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
44359     } catch (std::out_of_range& e) {
44360       {
44361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44362       };
44363     } catch (std::exception& e) {
44364       {
44365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44366       };
44367     } catch (Dali::DaliException e) {
44368       {
44369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44370       };
44371     } catch (...) {
44372       {
44373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44374       };
44375     }
44376   }
44377
44378   jresult = result;
44379   return jresult;
44380 }
44381
44382
44383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
44384   unsigned int jresult ;
44385   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44386   unsigned int result;
44387
44388   arg1 = (Dali::NativeImageInterface *)jarg1;
44389   {
44390     try {
44391       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
44392     } catch (std::out_of_range& e) {
44393       {
44394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44395       };
44396     } catch (std::exception& e) {
44397       {
44398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44399       };
44400     } catch (Dali::DaliException e) {
44401       {
44402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44403       };
44404     } catch (...) {
44405       {
44406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44407       };
44408     }
44409   }
44410
44411   jresult = result;
44412   return jresult;
44413 }
44414
44415
44416 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
44417   unsigned int jresult ;
44418   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44419   bool result;
44420
44421   arg1 = (Dali::NativeImageInterface *)jarg1;
44422   {
44423     try {
44424       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
44425     } catch (std::out_of_range& e) {
44426       {
44427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44428       };
44429     } catch (std::exception& e) {
44430       {
44431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44432       };
44433     } catch (Dali::DaliException e) {
44434       {
44435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44436       };
44437     } catch (...) {
44438       {
44439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44440       };
44441     }
44442   }
44443
44444   jresult = result;
44445   return jresult;
44446 }
44447
44448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
44449   int jresult ;
44450   int result;
44451
44452   result = (int)Dali::CameraActor::Property::TYPE;
44453   jresult = (int)result;
44454   return jresult;
44455 }
44456
44457
44458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
44459   int jresult ;
44460   int result;
44461
44462   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
44463   jresult = (int)result;
44464   return jresult;
44465 }
44466
44467
44468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
44469   int jresult ;
44470   int result;
44471
44472   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
44473   jresult = (int)result;
44474   return jresult;
44475 }
44476
44477
44478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
44479   int jresult ;
44480   int result;
44481
44482   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
44483   jresult = (int)result;
44484   return jresult;
44485 }
44486
44487
44488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
44489   int jresult ;
44490   int result;
44491
44492   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
44493   jresult = (int)result;
44494   return jresult;
44495 }
44496
44497
44498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
44499   int jresult ;
44500   int result;
44501
44502   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
44503   jresult = (int)result;
44504   return jresult;
44505 }
44506
44507
44508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
44509   int jresult ;
44510   int result;
44511
44512   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
44513   jresult = (int)result;
44514   return jresult;
44515 }
44516
44517
44518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
44519   int jresult ;
44520   int result;
44521
44522   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
44523   jresult = (int)result;
44524   return jresult;
44525 }
44526
44527
44528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
44529   int jresult ;
44530   int result;
44531
44532   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
44533   jresult = (int)result;
44534   return jresult;
44535 }
44536
44537
44538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
44539   int jresult ;
44540   int result;
44541
44542   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
44543   jresult = (int)result;
44544   return jresult;
44545 }
44546
44547
44548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
44549   int jresult ;
44550   int result;
44551
44552   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
44553   jresult = (int)result;
44554   return jresult;
44555 }
44556
44557
44558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
44559   int jresult ;
44560   int result;
44561
44562   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
44563   jresult = (int)result;
44564   return jresult;
44565 }
44566
44567
44568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
44569   int jresult ;
44570   int result;
44571
44572   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
44573   jresult = (int)result;
44574   return jresult;
44575 }
44576
44577
44578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
44579   int jresult ;
44580   int result;
44581
44582   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
44583   jresult = (int)result;
44584   return jresult;
44585 }
44586
44587
44588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
44589   void * jresult ;
44590   Dali::CameraActor::Property *result = 0 ;
44591
44592   {
44593     try {
44594       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
44595     } catch (std::out_of_range& e) {
44596       {
44597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44598       };
44599     } catch (std::exception& e) {
44600       {
44601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44602       };
44603     } catch (Dali::DaliException e) {
44604       {
44605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44606       };
44607     } catch (...) {
44608       {
44609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44610       };
44611     }
44612   }
44613
44614   jresult = (void *)result;
44615   return jresult;
44616 }
44617
44618
44619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
44620   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
44621
44622   arg1 = (Dali::CameraActor::Property *)jarg1;
44623   {
44624     try {
44625       delete arg1;
44626     } catch (std::out_of_range& e) {
44627       {
44628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44629       };
44630     } catch (std::exception& e) {
44631       {
44632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44633       };
44634     } catch (Dali::DaliException e) {
44635       {
44636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44637       };
44638     } catch (...) {
44639       {
44640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44641       };
44642     }
44643   }
44644
44645 }
44646
44647
44648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
44649   void * jresult ;
44650   Dali::CameraActor *result = 0 ;
44651
44652   {
44653     try {
44654       result = (Dali::CameraActor *)new Dali::CameraActor();
44655     } catch (std::out_of_range& e) {
44656       {
44657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44658       };
44659     } catch (std::exception& e) {
44660       {
44661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44662       };
44663     } catch (Dali::DaliException e) {
44664       {
44665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44666       };
44667     } catch (...) {
44668       {
44669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44670       };
44671     }
44672   }
44673
44674   jresult = (void *)result;
44675   return jresult;
44676 }
44677
44678
44679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
44680   void * jresult ;
44681   Dali::CameraActor result;
44682
44683   {
44684     try {
44685       result = Dali::CameraActor::New();
44686     } catch (std::out_of_range& e) {
44687       {
44688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44689       };
44690     } catch (std::exception& e) {
44691       {
44692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44693       };
44694     } catch (Dali::DaliException e) {
44695       {
44696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44697       };
44698     } catch (...) {
44699       {
44700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44701       };
44702     }
44703   }
44704
44705   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44706   return jresult;
44707 }
44708
44709
44710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
44711   void * jresult ;
44712   Dali::Size *arg1 = 0 ;
44713   Dali::CameraActor result;
44714
44715   arg1 = (Dali::Size *)jarg1;
44716   if (!arg1) {
44717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44718     return 0;
44719   }
44720   {
44721     try {
44722       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
44723     } catch (std::out_of_range& e) {
44724       {
44725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44726       };
44727     } catch (std::exception& e) {
44728       {
44729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44730       };
44731     } catch (Dali::DaliException e) {
44732       {
44733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44734       };
44735     } catch (...) {
44736       {
44737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44738       };
44739     }
44740   }
44741
44742   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44743   return jresult;
44744 }
44745
44746
44747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
44748   void * jresult ;
44749   Dali::BaseHandle arg1 ;
44750   Dali::BaseHandle *argp1 ;
44751   Dali::CameraActor result;
44752
44753   argp1 = (Dali::BaseHandle *)jarg1;
44754   if (!argp1) {
44755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44756     return 0;
44757   }
44758   arg1 = *argp1;
44759   {
44760     try {
44761       result = Dali::CameraActor::DownCast(arg1);
44762     } catch (std::out_of_range& e) {
44763       {
44764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44765       };
44766     } catch (std::exception& e) {
44767       {
44768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44769       };
44770     } catch (Dali::DaliException e) {
44771       {
44772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44773       };
44774     } catch (...) {
44775       {
44776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44777       };
44778     }
44779   }
44780
44781   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44782   return jresult;
44783 }
44784
44785
44786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
44787   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44788
44789   arg1 = (Dali::CameraActor *)jarg1;
44790   {
44791     try {
44792       delete arg1;
44793     } catch (std::out_of_range& e) {
44794       {
44795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44796       };
44797     } catch (std::exception& e) {
44798       {
44799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44800       };
44801     } catch (Dali::DaliException e) {
44802       {
44803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44804       };
44805     } catch (...) {
44806       {
44807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44808       };
44809     }
44810   }
44811
44812 }
44813
44814
44815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
44816   void * jresult ;
44817   Dali::CameraActor *arg1 = 0 ;
44818   Dali::CameraActor *result = 0 ;
44819
44820   arg1 = (Dali::CameraActor *)jarg1;
44821   if (!arg1) {
44822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44823     return 0;
44824   }
44825   {
44826     try {
44827       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
44828     } catch (std::out_of_range& e) {
44829       {
44830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44831       };
44832     } catch (std::exception& e) {
44833       {
44834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44835       };
44836     } catch (Dali::DaliException e) {
44837       {
44838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44839       };
44840     } catch (...) {
44841       {
44842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44843       };
44844     }
44845   }
44846
44847   jresult = (void *)result;
44848   return jresult;
44849 }
44850
44851
44852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
44853   void * jresult ;
44854   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44855   Dali::CameraActor *arg2 = 0 ;
44856   Dali::CameraActor *result = 0 ;
44857
44858   arg1 = (Dali::CameraActor *)jarg1;
44859   arg2 = (Dali::CameraActor *)jarg2;
44860   if (!arg2) {
44861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44862     return 0;
44863   }
44864   {
44865     try {
44866       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
44867     } catch (std::out_of_range& e) {
44868       {
44869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44870       };
44871     } catch (std::exception& e) {
44872       {
44873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44874       };
44875     } catch (Dali::DaliException e) {
44876       {
44877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44878       };
44879     } catch (...) {
44880       {
44881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44882       };
44883     }
44884   }
44885
44886   jresult = (void *)result;
44887   return jresult;
44888 }
44889
44890
44891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
44892   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44893   Dali::Camera::Type arg2 ;
44894
44895   arg1 = (Dali::CameraActor *)jarg1;
44896   arg2 = (Dali::Camera::Type)jarg2;
44897   {
44898     try {
44899       (arg1)->SetType(arg2);
44900     } catch (std::out_of_range& e) {
44901       {
44902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44903       };
44904     } catch (std::exception& e) {
44905       {
44906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44907       };
44908     } catch (Dali::DaliException e) {
44909       {
44910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44911       };
44912     } catch (...) {
44913       {
44914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44915       };
44916     }
44917   }
44918
44919 }
44920
44921
44922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
44923   int jresult ;
44924   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44925   Dali::Camera::Type result;
44926
44927   arg1 = (Dali::CameraActor *)jarg1;
44928   {
44929     try {
44930       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
44931     } catch (std::out_of_range& e) {
44932       {
44933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44934       };
44935     } catch (std::exception& e) {
44936       {
44937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44938       };
44939     } catch (Dali::DaliException e) {
44940       {
44941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44942       };
44943     } catch (...) {
44944       {
44945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44946       };
44947     }
44948   }
44949
44950   jresult = (int)result;
44951   return jresult;
44952 }
44953
44954
44955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
44956   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44957   Dali::Camera::ProjectionMode arg2 ;
44958
44959   arg1 = (Dali::CameraActor *)jarg1;
44960   arg2 = (Dali::Camera::ProjectionMode)jarg2;
44961   {
44962     try {
44963       (arg1)->SetProjectionMode(arg2);
44964     } catch (std::out_of_range& e) {
44965       {
44966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44967       };
44968     } catch (std::exception& e) {
44969       {
44970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44971       };
44972     } catch (Dali::DaliException e) {
44973       {
44974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44975       };
44976     } catch (...) {
44977       {
44978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44979       };
44980     }
44981   }
44982
44983 }
44984
44985
44986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
44987   int jresult ;
44988   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44989   Dali::Camera::ProjectionMode result;
44990
44991   arg1 = (Dali::CameraActor *)jarg1;
44992   {
44993     try {
44994       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
44995     } catch (std::out_of_range& e) {
44996       {
44997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44998       };
44999     } catch (std::exception& e) {
45000       {
45001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45002       };
45003     } catch (Dali::DaliException e) {
45004       {
45005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45006       };
45007     } catch (...) {
45008       {
45009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45010       };
45011     }
45012   }
45013
45014   jresult = (int)result;
45015   return jresult;
45016 }
45017
45018
45019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
45020   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45021   float arg2 ;
45022
45023   arg1 = (Dali::CameraActor *)jarg1;
45024   arg2 = (float)jarg2;
45025   {
45026     try {
45027       (arg1)->SetFieldOfView(arg2);
45028     } catch (std::out_of_range& e) {
45029       {
45030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45031       };
45032     } catch (std::exception& e) {
45033       {
45034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45035       };
45036     } catch (Dali::DaliException e) {
45037       {
45038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45039       };
45040     } catch (...) {
45041       {
45042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45043       };
45044     }
45045   }
45046
45047 }
45048
45049
45050 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
45051   float jresult ;
45052   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45053   float result;
45054
45055   arg1 = (Dali::CameraActor *)jarg1;
45056   {
45057     try {
45058       result = (float)(arg1)->GetFieldOfView();
45059     } catch (std::out_of_range& e) {
45060       {
45061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45062       };
45063     } catch (std::exception& e) {
45064       {
45065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45066       };
45067     } catch (Dali::DaliException e) {
45068       {
45069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45070       };
45071     } catch (...) {
45072       {
45073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45074       };
45075     }
45076   }
45077
45078   jresult = result;
45079   return jresult;
45080 }
45081
45082
45083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
45084   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45085   float arg2 ;
45086
45087   arg1 = (Dali::CameraActor *)jarg1;
45088   arg2 = (float)jarg2;
45089   {
45090     try {
45091       (arg1)->SetAspectRatio(arg2);
45092     } catch (std::out_of_range& e) {
45093       {
45094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45095       };
45096     } catch (std::exception& e) {
45097       {
45098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45099       };
45100     } catch (Dali::DaliException e) {
45101       {
45102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45103       };
45104     } catch (...) {
45105       {
45106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45107       };
45108     }
45109   }
45110
45111 }
45112
45113
45114 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
45115   float jresult ;
45116   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45117   float result;
45118
45119   arg1 = (Dali::CameraActor *)jarg1;
45120   {
45121     try {
45122       result = (float)(arg1)->GetAspectRatio();
45123     } catch (std::out_of_range& e) {
45124       {
45125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45126       };
45127     } catch (std::exception& e) {
45128       {
45129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45130       };
45131     } catch (Dali::DaliException e) {
45132       {
45133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45134       };
45135     } catch (...) {
45136       {
45137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45138       };
45139     }
45140   }
45141
45142   jresult = result;
45143   return jresult;
45144 }
45145
45146
45147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
45148   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45149   float arg2 ;
45150
45151   arg1 = (Dali::CameraActor *)jarg1;
45152   arg2 = (float)jarg2;
45153   {
45154     try {
45155       (arg1)->SetNearClippingPlane(arg2);
45156     } catch (std::out_of_range& e) {
45157       {
45158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45159       };
45160     } catch (std::exception& e) {
45161       {
45162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45163       };
45164     } catch (Dali::DaliException e) {
45165       {
45166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45167       };
45168     } catch (...) {
45169       {
45170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45171       };
45172     }
45173   }
45174
45175 }
45176
45177
45178 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
45179   float jresult ;
45180   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45181   float result;
45182
45183   arg1 = (Dali::CameraActor *)jarg1;
45184   {
45185     try {
45186       result = (float)(arg1)->GetNearClippingPlane();
45187     } catch (std::out_of_range& e) {
45188       {
45189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45190       };
45191     } catch (std::exception& e) {
45192       {
45193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45194       };
45195     } catch (Dali::DaliException e) {
45196       {
45197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45198       };
45199     } catch (...) {
45200       {
45201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45202       };
45203     }
45204   }
45205
45206   jresult = result;
45207   return jresult;
45208 }
45209
45210
45211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
45212   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45213   float arg2 ;
45214
45215   arg1 = (Dali::CameraActor *)jarg1;
45216   arg2 = (float)jarg2;
45217   {
45218     try {
45219       (arg1)->SetFarClippingPlane(arg2);
45220     } catch (std::out_of_range& e) {
45221       {
45222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45223       };
45224     } catch (std::exception& e) {
45225       {
45226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45227       };
45228     } catch (Dali::DaliException e) {
45229       {
45230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45231       };
45232     } catch (...) {
45233       {
45234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45235       };
45236     }
45237   }
45238
45239 }
45240
45241
45242 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
45243   float jresult ;
45244   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45245   float result;
45246
45247   arg1 = (Dali::CameraActor *)jarg1;
45248   {
45249     try {
45250       result = (float)(arg1)->GetFarClippingPlane();
45251     } catch (std::out_of_range& e) {
45252       {
45253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45254       };
45255     } catch (std::exception& e) {
45256       {
45257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45258       };
45259     } catch (Dali::DaliException e) {
45260       {
45261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45262       };
45263     } catch (...) {
45264       {
45265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45266       };
45267     }
45268   }
45269
45270   jresult = result;
45271   return jresult;
45272 }
45273
45274
45275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
45276   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45277   Dali::Vector3 *arg2 = 0 ;
45278
45279   arg1 = (Dali::CameraActor *)jarg1;
45280   arg2 = (Dali::Vector3 *)jarg2;
45281   if (!arg2) {
45282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
45283     return ;
45284   }
45285   {
45286     try {
45287       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
45288     } catch (std::out_of_range& e) {
45289       {
45290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45291       };
45292     } catch (std::exception& e) {
45293       {
45294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45295       };
45296     } catch (Dali::DaliException e) {
45297       {
45298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45299       };
45300     } catch (...) {
45301       {
45302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45303       };
45304     }
45305   }
45306
45307 }
45308
45309
45310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
45311   void * jresult ;
45312   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45313   Dali::Vector3 result;
45314
45315   arg1 = (Dali::CameraActor *)jarg1;
45316   {
45317     try {
45318       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
45319     } catch (std::out_of_range& e) {
45320       {
45321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45322       };
45323     } catch (std::exception& e) {
45324       {
45325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45326       };
45327     } catch (Dali::DaliException e) {
45328       {
45329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45330       };
45331     } catch (...) {
45332       {
45333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45334       };
45335     }
45336   }
45337
45338   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
45339   return jresult;
45340 }
45341
45342
45343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
45344   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45345   bool arg2 ;
45346
45347   arg1 = (Dali::CameraActor *)jarg1;
45348   arg2 = jarg2 ? true : false;
45349   {
45350     try {
45351       (arg1)->SetInvertYAxis(arg2);
45352     } catch (std::out_of_range& e) {
45353       {
45354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45355       };
45356     } catch (std::exception& e) {
45357       {
45358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45359       };
45360     } catch (Dali::DaliException e) {
45361       {
45362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45363       };
45364     } catch (...) {
45365       {
45366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45367       };
45368     }
45369   }
45370
45371 }
45372
45373
45374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
45375   unsigned int jresult ;
45376   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45377   bool result;
45378
45379   arg1 = (Dali::CameraActor *)jarg1;
45380   {
45381     try {
45382       result = (bool)(arg1)->GetInvertYAxis();
45383     } catch (std::out_of_range& e) {
45384       {
45385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45386       };
45387     } catch (std::exception& e) {
45388       {
45389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45390       };
45391     } catch (Dali::DaliException e) {
45392       {
45393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45394       };
45395     } catch (...) {
45396       {
45397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45398       };
45399     }
45400   }
45401
45402   jresult = result;
45403   return jresult;
45404 }
45405
45406
45407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
45408   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45409   Dali::Size *arg2 = 0 ;
45410
45411   arg1 = (Dali::CameraActor *)jarg1;
45412   arg2 = (Dali::Size *)jarg2;
45413   if (!arg2) {
45414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45415     return ;
45416   }
45417   {
45418     try {
45419       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
45420     } catch (std::out_of_range& e) {
45421       {
45422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45423       };
45424     } catch (std::exception& e) {
45425       {
45426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45427       };
45428     } catch (Dali::DaliException e) {
45429       {
45430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45431       };
45432     } catch (...) {
45433       {
45434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45435       };
45436     }
45437   }
45438
45439 }
45440
45441
45442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
45443   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45444   Dali::Size *arg2 = 0 ;
45445
45446   arg1 = (Dali::CameraActor *)jarg1;
45447   arg2 = (Dali::Size *)jarg2;
45448   if (!arg2) {
45449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45450     return ;
45451   }
45452   {
45453     try {
45454       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
45455     } catch (std::out_of_range& e) {
45456       {
45457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45458       };
45459     } catch (std::exception& e) {
45460       {
45461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45462       };
45463     } catch (Dali::DaliException e) {
45464       {
45465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45466       };
45467     } catch (...) {
45468       {
45469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45470       };
45471     }
45472   }
45473
45474 }
45475
45476
45477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
45478   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45479   float arg2 ;
45480   float arg3 ;
45481   float arg4 ;
45482   float arg5 ;
45483   float arg6 ;
45484   float arg7 ;
45485
45486   arg1 = (Dali::CameraActor *)jarg1;
45487   arg2 = (float)jarg2;
45488   arg3 = (float)jarg3;
45489   arg4 = (float)jarg4;
45490   arg5 = (float)jarg5;
45491   arg6 = (float)jarg6;
45492   arg7 = (float)jarg7;
45493   {
45494     try {
45495       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
45496     } catch (std::out_of_range& e) {
45497       {
45498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45499       };
45500     } catch (std::exception& e) {
45501       {
45502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45503       };
45504     } catch (Dali::DaliException e) {
45505       {
45506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45507       };
45508     } catch (...) {
45509       {
45510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45511       };
45512     }
45513   }
45514
45515 }
45516
45517
45518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
45519   void * jresult ;
45520   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45521
45522   {
45523     try {
45524       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
45525     } catch (std::out_of_range& e) {
45526       {
45527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45528       };
45529     } catch (std::exception& e) {
45530       {
45531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45532       };
45533     } catch (Dali::DaliException e) {
45534       {
45535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45536       };
45537     } catch (...) {
45538       {
45539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45540       };
45541     }
45542   }
45543
45544   jresult = (void *)result;
45545   return jresult;
45546 }
45547
45548
45549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
45550   void * jresult ;
45551   std::string arg1 ;
45552   Dali::Property::Value arg2 ;
45553   Dali::Property::Value *argp2 ;
45554   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45555
45556   if (!jarg1) {
45557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45558     return 0;
45559   }
45560   (&arg1)->assign(jarg1);
45561   argp2 = (Dali::Property::Value *)jarg2;
45562   if (!argp2) {
45563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
45564     return 0;
45565   }
45566   arg2 = *argp2;
45567   {
45568     try {
45569       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
45570     } catch (std::out_of_range& e) {
45571       {
45572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45573       };
45574     } catch (std::exception& e) {
45575       {
45576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45577       };
45578     } catch (Dali::DaliException e) {
45579       {
45580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45581       };
45582     } catch (...) {
45583       {
45584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45585       };
45586     }
45587   }
45588
45589   jresult = (void *)result;
45590   return jresult;
45591 }
45592
45593
45594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
45595   void * jresult ;
45596   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
45597   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45598
45599   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45600   if (!arg1) {
45601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
45602     return 0;
45603   }
45604   {
45605     try {
45606       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);
45607     } catch (std::out_of_range& e) {
45608       {
45609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45610       };
45611     } catch (std::exception& e) {
45612       {
45613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45614       };
45615     } catch (Dali::DaliException e) {
45616       {
45617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45618       };
45619     } catch (...) {
45620       {
45621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45622       };
45623     }
45624   }
45625
45626   jresult = (void *)result;
45627   return jresult;
45628 }
45629
45630
45631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
45632   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45633   std::string *arg2 = 0 ;
45634
45635   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45636   if (!jarg2) {
45637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45638     return ;
45639   }
45640   std::string arg2_str(jarg2);
45641   arg2 = &arg2_str;
45642   if (arg1) (arg1)->first = *arg2;
45643
45644   //argout typemap for const std::string&
45645
45646 }
45647
45648
45649 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
45650   char * jresult ;
45651   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45652   std::string *result = 0 ;
45653
45654   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45655   result = (std::string *) & ((arg1)->first);
45656   jresult = SWIG_csharp_string_callback(result->c_str());
45657   return jresult;
45658 }
45659
45660
45661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
45662   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45663   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
45664
45665   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45666   arg2 = (Dali::Property::Value *)jarg2;
45667   if (arg1) (arg1)->second = *arg2;
45668 }
45669
45670
45671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
45672   void * jresult ;
45673   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45674   Dali::Property::Value *result = 0 ;
45675
45676   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45677   result = (Dali::Property::Value *)& ((arg1)->second);
45678   jresult = (void *)result;
45679   return jresult;
45680 }
45681
45682
45683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
45684   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45685
45686   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45687   {
45688     try {
45689       delete arg1;
45690     } catch (std::out_of_range& e) {
45691       {
45692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45693       };
45694     } catch (std::exception& e) {
45695       {
45696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45697       };
45698     } catch (Dali::DaliException e) {
45699       {
45700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45701       };
45702     } catch (...) {
45703       {
45704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45705       };
45706     }
45707   }
45708
45709 }
45710
45711
45712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
45713   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45714
45715   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45716   {
45717     try {
45718       (arg1)->clear();
45719     } catch (std::out_of_range& e) {
45720       {
45721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45722       };
45723     } catch (std::exception& e) {
45724       {
45725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45726       };
45727     } catch (Dali::DaliException e) {
45728       {
45729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45730       };
45731     } catch (...) {
45732       {
45733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45734       };
45735     }
45736   }
45737
45738 }
45739
45740
45741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
45742   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45743   Dali::TouchPoint *arg2 = 0 ;
45744
45745   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45746   arg2 = (Dali::TouchPoint *)jarg2;
45747   if (!arg2) {
45748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45749     return ;
45750   }
45751   {
45752     try {
45753       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
45754     } catch (std::out_of_range& e) {
45755       {
45756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45757       };
45758     } catch (std::exception& e) {
45759       {
45760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45761       };
45762     } catch (Dali::DaliException e) {
45763       {
45764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45765       };
45766     } catch (...) {
45767       {
45768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45769       };
45770     }
45771   }
45772
45773 }
45774
45775
45776 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
45777   unsigned long jresult ;
45778   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45779   std::vector< Dali::TouchPoint >::size_type result;
45780
45781   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45782   {
45783     try {
45784       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
45785     } catch (std::out_of_range& e) {
45786       {
45787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45788       };
45789     } catch (std::exception& e) {
45790       {
45791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45792       };
45793     } catch (Dali::DaliException e) {
45794       {
45795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45796       };
45797     } catch (...) {
45798       {
45799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45800       };
45801     }
45802   }
45803
45804   jresult = (unsigned long)result;
45805   return jresult;
45806 }
45807
45808
45809 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
45810   unsigned long jresult ;
45811   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45812   std::vector< Dali::TouchPoint >::size_type result;
45813
45814   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45815   {
45816     try {
45817       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
45818     } catch (std::out_of_range& e) {
45819       {
45820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45821       };
45822     } catch (std::exception& e) {
45823       {
45824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45825       };
45826     } catch (Dali::DaliException e) {
45827       {
45828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45829       };
45830     } catch (...) {
45831       {
45832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45833       };
45834     }
45835   }
45836
45837   jresult = (unsigned long)result;
45838   return jresult;
45839 }
45840
45841
45842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
45843   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45844   std::vector< Dali::TouchPoint >::size_type arg2 ;
45845
45846   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45847   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
45848   {
45849     try {
45850       (arg1)->reserve(arg2);
45851     } catch (std::out_of_range& e) {
45852       {
45853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45854       };
45855     } catch (std::exception& e) {
45856       {
45857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45858       };
45859     } catch (Dali::DaliException e) {
45860       {
45861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45862       };
45863     } catch (...) {
45864       {
45865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45866       };
45867     }
45868   }
45869
45870 }
45871
45872
45873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
45874   void * jresult ;
45875   std::vector< Dali::TouchPoint > *result = 0 ;
45876
45877   {
45878     try {
45879       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
45880     } catch (std::out_of_range& e) {
45881       {
45882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45883       };
45884     } catch (std::exception& e) {
45885       {
45886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45887       };
45888     } catch (Dali::DaliException e) {
45889       {
45890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45891       };
45892     } catch (...) {
45893       {
45894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45895       };
45896     }
45897   }
45898
45899   jresult = (void *)result;
45900   return jresult;
45901 }
45902
45903
45904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
45905   void * jresult ;
45906   std::vector< Dali::TouchPoint > *arg1 = 0 ;
45907   std::vector< Dali::TouchPoint > *result = 0 ;
45908
45909   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45910   if (!arg1) {
45911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45912     return 0;
45913   }
45914   {
45915     try {
45916       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
45917     } catch (std::out_of_range& e) {
45918       {
45919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45920       };
45921     } catch (std::exception& e) {
45922       {
45923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45924       };
45925     } catch (Dali::DaliException e) {
45926       {
45927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45928       };
45929     } catch (...) {
45930       {
45931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45932       };
45933     }
45934   }
45935
45936   jresult = (void *)result;
45937   return jresult;
45938 }
45939
45940
45941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
45942   void * jresult ;
45943   int arg1 ;
45944   std::vector< Dali::TouchPoint > *result = 0 ;
45945
45946   arg1 = (int)jarg1;
45947   {
45948     try {
45949       try {
45950         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
45951       }
45952       catch(std::out_of_range &_e) {
45953         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45954         return 0;
45955       }
45956
45957     } catch (std::out_of_range& e) {
45958       {
45959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45960       };
45961     } catch (std::exception& e) {
45962       {
45963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45964       };
45965     } catch (Dali::DaliException e) {
45966       {
45967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45968       };
45969     } catch (...) {
45970       {
45971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45972       };
45973     }
45974   }
45975
45976   jresult = (void *)result;
45977   return jresult;
45978 }
45979
45980
45981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
45982   void * jresult ;
45983   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45984   int arg2 ;
45985   SwigValueWrapper< Dali::TouchPoint > result;
45986
45987   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45988   arg2 = (int)jarg2;
45989   {
45990     try {
45991       try {
45992         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
45993       }
45994       catch(std::out_of_range &_e) {
45995         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45996         return 0;
45997       }
45998
45999     } catch (std::out_of_range& e) {
46000       {
46001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46002       };
46003     } catch (std::exception& e) {
46004       {
46005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46006       };
46007     } catch (Dali::DaliException e) {
46008       {
46009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46010       };
46011     } catch (...) {
46012       {
46013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46014       };
46015     }
46016   }
46017
46018   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
46019   return jresult;
46020 }
46021
46022
46023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
46024   void * jresult ;
46025   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46026   int arg2 ;
46027   Dali::TouchPoint *result = 0 ;
46028
46029   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46030   arg2 = (int)jarg2;
46031   {
46032     try {
46033       try {
46034         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
46035       }
46036       catch(std::out_of_range &_e) {
46037         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46038         return 0;
46039       }
46040
46041     } catch (std::out_of_range& e) {
46042       {
46043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46044       };
46045     } catch (std::exception& e) {
46046       {
46047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46048       };
46049     } catch (Dali::DaliException e) {
46050       {
46051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46052       };
46053     } catch (...) {
46054       {
46055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46056       };
46057     }
46058   }
46059
46060   jresult = (void *)result;
46061   return jresult;
46062 }
46063
46064
46065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
46066   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46067   int arg2 ;
46068   Dali::TouchPoint *arg3 = 0 ;
46069
46070   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46071   arg2 = (int)jarg2;
46072   arg3 = (Dali::TouchPoint *)jarg3;
46073   if (!arg3) {
46074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46075     return ;
46076   }
46077   {
46078     try {
46079       try {
46080         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46081       }
46082       catch(std::out_of_range &_e) {
46083         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46084         return ;
46085       }
46086
46087     } catch (std::out_of_range& e) {
46088       {
46089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46090       };
46091     } catch (std::exception& e) {
46092       {
46093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46094       };
46095     } catch (Dali::DaliException e) {
46096       {
46097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46098       };
46099     } catch (...) {
46100       {
46101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46102       };
46103     }
46104   }
46105
46106 }
46107
46108
46109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
46110   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46111   std::vector< Dali::TouchPoint > *arg2 = 0 ;
46112
46113   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46114   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
46115   if (!arg2) {
46116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46117     return ;
46118   }
46119   {
46120     try {
46121       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
46122     } catch (std::out_of_range& e) {
46123       {
46124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46125       };
46126     } catch (std::exception& e) {
46127       {
46128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46129       };
46130     } catch (Dali::DaliException e) {
46131       {
46132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46133       };
46134     } catch (...) {
46135       {
46136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46137       };
46138     }
46139   }
46140
46141 }
46142
46143
46144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
46145   void * jresult ;
46146   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46147   int arg2 ;
46148   int arg3 ;
46149   std::vector< Dali::TouchPoint > *result = 0 ;
46150
46151   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46152   arg2 = (int)jarg2;
46153   arg3 = (int)jarg3;
46154   {
46155     try {
46156       try {
46157         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
46158       }
46159       catch(std::out_of_range &_e) {
46160         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46161         return 0;
46162       }
46163       catch(std::invalid_argument &_e) {
46164         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46165         return 0;
46166       }
46167
46168     } catch (std::out_of_range& e) {
46169       {
46170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46171       };
46172     } catch (std::exception& e) {
46173       {
46174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46175       };
46176     } catch (Dali::DaliException e) {
46177       {
46178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46179       };
46180     } catch (...) {
46181       {
46182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46183       };
46184     }
46185   }
46186
46187   jresult = (void *)result;
46188   return jresult;
46189 }
46190
46191
46192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
46193   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46194   int arg2 ;
46195   Dali::TouchPoint *arg3 = 0 ;
46196
46197   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46198   arg2 = (int)jarg2;
46199   arg3 = (Dali::TouchPoint *)jarg3;
46200   if (!arg3) {
46201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46202     return ;
46203   }
46204   {
46205     try {
46206       try {
46207         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46208       }
46209       catch(std::out_of_range &_e) {
46210         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46211         return ;
46212       }
46213
46214     } catch (std::out_of_range& e) {
46215       {
46216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46217       };
46218     } catch (std::exception& e) {
46219       {
46220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46221       };
46222     } catch (Dali::DaliException e) {
46223       {
46224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46225       };
46226     } catch (...) {
46227       {
46228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46229       };
46230     }
46231   }
46232
46233 }
46234
46235
46236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
46237   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46238   int arg2 ;
46239   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46240
46241   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46242   arg2 = (int)jarg2;
46243   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46244   if (!arg3) {
46245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46246     return ;
46247   }
46248   {
46249     try {
46250       try {
46251         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
46252       }
46253       catch(std::out_of_range &_e) {
46254         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46255         return ;
46256       }
46257
46258     } catch (std::out_of_range& e) {
46259       {
46260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46261       };
46262     } catch (std::exception& e) {
46263       {
46264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46265       };
46266     } catch (Dali::DaliException e) {
46267       {
46268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46269       };
46270     } catch (...) {
46271       {
46272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46273       };
46274     }
46275   }
46276
46277 }
46278
46279
46280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
46281   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46282   int arg2 ;
46283
46284   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46285   arg2 = (int)jarg2;
46286   {
46287     try {
46288       try {
46289         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
46290       }
46291       catch(std::out_of_range &_e) {
46292         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46293         return ;
46294       }
46295
46296     } catch (std::out_of_range& e) {
46297       {
46298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46299       };
46300     } catch (std::exception& e) {
46301       {
46302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46303       };
46304     } catch (Dali::DaliException e) {
46305       {
46306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46307       };
46308     } catch (...) {
46309       {
46310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46311       };
46312     }
46313   }
46314
46315 }
46316
46317
46318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
46319   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46320   int arg2 ;
46321   int arg3 ;
46322
46323   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46324   arg2 = (int)jarg2;
46325   arg3 = (int)jarg3;
46326   {
46327     try {
46328       try {
46329         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
46330       }
46331       catch(std::out_of_range &_e) {
46332         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46333         return ;
46334       }
46335       catch(std::invalid_argument &_e) {
46336         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46337         return ;
46338       }
46339
46340     } catch (std::out_of_range& e) {
46341       {
46342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46343       };
46344     } catch (std::exception& e) {
46345       {
46346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46347       };
46348     } catch (Dali::DaliException e) {
46349       {
46350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46351       };
46352     } catch (...) {
46353       {
46354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46355       };
46356     }
46357   }
46358
46359 }
46360
46361
46362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
46363   void * jresult ;
46364   Dali::TouchPoint *arg1 = 0 ;
46365   int arg2 ;
46366   std::vector< Dali::TouchPoint > *result = 0 ;
46367
46368   arg1 = (Dali::TouchPoint *)jarg1;
46369   if (!arg1) {
46370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46371     return 0;
46372   }
46373   arg2 = (int)jarg2;
46374   {
46375     try {
46376       try {
46377         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
46378       }
46379       catch(std::out_of_range &_e) {
46380         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46381         return 0;
46382       }
46383
46384     } catch (std::out_of_range& e) {
46385       {
46386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46387       };
46388     } catch (std::exception& e) {
46389       {
46390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46391       };
46392     } catch (Dali::DaliException e) {
46393       {
46394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46395       };
46396     } catch (...) {
46397       {
46398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46399       };
46400     }
46401   }
46402
46403   jresult = (void *)result;
46404   return jresult;
46405 }
46406
46407
46408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
46409   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46410
46411   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46412   {
46413     try {
46414       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
46415     } catch (std::out_of_range& e) {
46416       {
46417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46418       };
46419     } catch (std::exception& e) {
46420       {
46421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46422       };
46423     } catch (Dali::DaliException e) {
46424       {
46425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46426       };
46427     } catch (...) {
46428       {
46429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46430       };
46431     }
46432   }
46433
46434 }
46435
46436
46437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
46438   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46439   int arg2 ;
46440   int arg3 ;
46441
46442   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46443   arg2 = (int)jarg2;
46444   arg3 = (int)jarg3;
46445   {
46446     try {
46447       try {
46448         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
46449       }
46450       catch(std::out_of_range &_e) {
46451         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46452         return ;
46453       }
46454       catch(std::invalid_argument &_e) {
46455         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46456         return ;
46457       }
46458
46459     } catch (std::out_of_range& e) {
46460       {
46461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46462       };
46463     } catch (std::exception& e) {
46464       {
46465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46466       };
46467     } catch (Dali::DaliException e) {
46468       {
46469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46470       };
46471     } catch (...) {
46472       {
46473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46474       };
46475     }
46476   }
46477
46478 }
46479
46480
46481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
46482   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46483   int arg2 ;
46484   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46485
46486   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46487   arg2 = (int)jarg2;
46488   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46489   if (!arg3) {
46490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46491     return ;
46492   }
46493   {
46494     try {
46495       try {
46496         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
46497       }
46498       catch(std::out_of_range &_e) {
46499         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46500         return ;
46501       }
46502
46503     } catch (std::out_of_range& e) {
46504       {
46505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46506       };
46507     } catch (std::exception& e) {
46508       {
46509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46510       };
46511     } catch (Dali::DaliException e) {
46512       {
46513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46514       };
46515     } catch (...) {
46516       {
46517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46518       };
46519     }
46520   }
46521
46522 }
46523
46524
46525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
46526   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46527
46528   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46529   {
46530     try {
46531       delete arg1;
46532     } catch (std::out_of_range& e) {
46533       {
46534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46535       };
46536     } catch (std::exception& e) {
46537       {
46538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46539       };
46540     } catch (Dali::DaliException e) {
46541       {
46542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46543       };
46544     } catch (...) {
46545       {
46546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46547       };
46548     }
46549   }
46550
46551 }
46552
46553
46554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
46555   void * jresult ;
46556   Dali::Rect< int > *result = 0 ;
46557
46558   {
46559     try {
46560       result = (Dali::Rect< int > *)new Dali::Rect< int >();
46561     } catch (std::out_of_range& e) {
46562       {
46563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46564       };
46565     } catch (std::exception& e) {
46566       {
46567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46568       };
46569     } catch (Dali::DaliException e) {
46570       {
46571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46572       };
46573     } catch (...) {
46574       {
46575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46576       };
46577     }
46578   }
46579
46580   jresult = (void *)result;
46581   return jresult;
46582 }
46583
46584
46585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
46586   void * jresult ;
46587   int arg1 ;
46588   int arg2 ;
46589   int arg3 ;
46590   int arg4 ;
46591   Dali::Rect< int > *result = 0 ;
46592
46593   arg1 = (int)jarg1;
46594   arg2 = (int)jarg2;
46595   arg3 = (int)jarg3;
46596   arg4 = (int)jarg4;
46597   {
46598     try {
46599       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
46600     } catch (std::out_of_range& e) {
46601       {
46602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46603       };
46604     } catch (std::exception& e) {
46605       {
46606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46607       };
46608     } catch (Dali::DaliException e) {
46609       {
46610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46611       };
46612     } catch (...) {
46613       {
46614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46615       };
46616     }
46617   }
46618
46619   jresult = (void *)result;
46620   return jresult;
46621 }
46622
46623
46624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
46625   void * jresult ;
46626   Dali::Rect< int > *arg1 = 0 ;
46627   Dali::Rect< int > *result = 0 ;
46628
46629   arg1 = (Dali::Rect< int > *)jarg1;
46630   if (!arg1) {
46631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46632     return 0;
46633   }
46634   {
46635     try {
46636       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
46637     } catch (std::out_of_range& e) {
46638       {
46639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46640       };
46641     } catch (std::exception& e) {
46642       {
46643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46644       };
46645     } catch (Dali::DaliException e) {
46646       {
46647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46648       };
46649     } catch (...) {
46650       {
46651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46652       };
46653     }
46654   }
46655
46656   jresult = (void *)result;
46657   return jresult;
46658 }
46659
46660
46661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
46662   void * jresult ;
46663   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46664   Dali::Rect< int > *arg2 = 0 ;
46665   Dali::Rect< int > *result = 0 ;
46666
46667   arg1 = (Dali::Rect< int > *)jarg1;
46668   arg2 = (Dali::Rect< int > *)jarg2;
46669   if (!arg2) {
46670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46671     return 0;
46672   }
46673   {
46674     try {
46675       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
46676     } catch (std::out_of_range& e) {
46677       {
46678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46679       };
46680     } catch (std::exception& e) {
46681       {
46682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46683       };
46684     } catch (Dali::DaliException e) {
46685       {
46686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46687       };
46688     } catch (...) {
46689       {
46690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46691       };
46692     }
46693   }
46694
46695   jresult = (void *)result;
46696   return jresult;
46697 }
46698
46699
46700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
46701   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46702   int arg2 ;
46703   int arg3 ;
46704   int arg4 ;
46705   int arg5 ;
46706
46707   arg1 = (Dali::Rect< int > *)jarg1;
46708   arg2 = (int)jarg2;
46709   arg3 = (int)jarg3;
46710   arg4 = (int)jarg4;
46711   arg5 = (int)jarg5;
46712   {
46713     try {
46714       (arg1)->Set(arg2,arg3,arg4,arg5);
46715     } catch (std::out_of_range& e) {
46716       {
46717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46718       };
46719     } catch (std::exception& e) {
46720       {
46721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46722       };
46723     } catch (Dali::DaliException e) {
46724       {
46725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46726       };
46727     } catch (...) {
46728       {
46729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46730       };
46731     }
46732   }
46733
46734 }
46735
46736
46737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
46738   unsigned int jresult ;
46739   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46740   bool result;
46741
46742   arg1 = (Dali::Rect< int > *)jarg1;
46743   {
46744     try {
46745       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
46746     } catch (std::out_of_range& e) {
46747       {
46748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46749       };
46750     } catch (std::exception& e) {
46751       {
46752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46753       };
46754     } catch (Dali::DaliException e) {
46755       {
46756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46757       };
46758     } catch (...) {
46759       {
46760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46761       };
46762     }
46763   }
46764
46765   jresult = result;
46766   return jresult;
46767 }
46768
46769
46770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
46771   int jresult ;
46772   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46773   int result;
46774
46775   arg1 = (Dali::Rect< int > *)jarg1;
46776   {
46777     try {
46778       result = (int)((Dali::Rect< int > const *)arg1)->Left();
46779     } catch (std::out_of_range& e) {
46780       {
46781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46782       };
46783     } catch (std::exception& e) {
46784       {
46785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46786       };
46787     } catch (Dali::DaliException e) {
46788       {
46789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46790       };
46791     } catch (...) {
46792       {
46793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46794       };
46795     }
46796   }
46797
46798   jresult = result;
46799   return jresult;
46800 }
46801
46802
46803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
46804   int jresult ;
46805   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46806   int result;
46807
46808   arg1 = (Dali::Rect< int > *)jarg1;
46809   {
46810     try {
46811       result = (int)((Dali::Rect< int > const *)arg1)->Right();
46812     } catch (std::out_of_range& e) {
46813       {
46814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46815       };
46816     } catch (std::exception& e) {
46817       {
46818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46819       };
46820     } catch (Dali::DaliException e) {
46821       {
46822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46823       };
46824     } catch (...) {
46825       {
46826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46827       };
46828     }
46829   }
46830
46831   jresult = result;
46832   return jresult;
46833 }
46834
46835
46836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
46837   int jresult ;
46838   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46839   int result;
46840
46841   arg1 = (Dali::Rect< int > *)jarg1;
46842   {
46843     try {
46844       result = (int)((Dali::Rect< int > const *)arg1)->Top();
46845     } catch (std::out_of_range& e) {
46846       {
46847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46848       };
46849     } catch (std::exception& e) {
46850       {
46851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46852       };
46853     } catch (Dali::DaliException e) {
46854       {
46855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46856       };
46857     } catch (...) {
46858       {
46859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46860       };
46861     }
46862   }
46863
46864   jresult = result;
46865   return jresult;
46866 }
46867
46868
46869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
46870   int jresult ;
46871   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46872   int result;
46873
46874   arg1 = (Dali::Rect< int > *)jarg1;
46875   {
46876     try {
46877       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
46878     } catch (std::out_of_range& e) {
46879       {
46880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46881       };
46882     } catch (std::exception& e) {
46883       {
46884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46885       };
46886     } catch (Dali::DaliException e) {
46887       {
46888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46889       };
46890     } catch (...) {
46891       {
46892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46893       };
46894     }
46895   }
46896
46897   jresult = result;
46898   return jresult;
46899 }
46900
46901
46902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
46903   int jresult ;
46904   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46905   int result;
46906
46907   arg1 = (Dali::Rect< int > *)jarg1;
46908   {
46909     try {
46910       result = (int)((Dali::Rect< int > const *)arg1)->Area();
46911     } catch (std::out_of_range& e) {
46912       {
46913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46914       };
46915     } catch (std::exception& e) {
46916       {
46917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46918       };
46919     } catch (Dali::DaliException e) {
46920       {
46921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46922       };
46923     } catch (...) {
46924       {
46925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46926       };
46927     }
46928   }
46929
46930   jresult = result;
46931   return jresult;
46932 }
46933
46934
46935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
46936   unsigned int jresult ;
46937   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46938   Dali::Rect< int > *arg2 = 0 ;
46939   bool result;
46940
46941   arg1 = (Dali::Rect< int > *)jarg1;
46942   arg2 = (Dali::Rect< int > *)jarg2;
46943   if (!arg2) {
46944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46945     return 0;
46946   }
46947   {
46948     try {
46949       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
46950     } catch (std::out_of_range& e) {
46951       {
46952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46953       };
46954     } catch (std::exception& e) {
46955       {
46956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46957       };
46958     } catch (Dali::DaliException e) {
46959       {
46960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46961       };
46962     } catch (...) {
46963       {
46964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46965       };
46966     }
46967   }
46968
46969   jresult = result;
46970   return jresult;
46971 }
46972
46973
46974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
46975   unsigned int jresult ;
46976   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46977   Dali::Rect< int > *arg2 = 0 ;
46978   bool result;
46979
46980   arg1 = (Dali::Rect< int > *)jarg1;
46981   arg2 = (Dali::Rect< int > *)jarg2;
46982   if (!arg2) {
46983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46984     return 0;
46985   }
46986   {
46987     try {
46988       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
46989     } catch (std::out_of_range& e) {
46990       {
46991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46992       };
46993     } catch (std::exception& e) {
46994       {
46995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46996       };
46997     } catch (Dali::DaliException e) {
46998       {
46999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47000       };
47001     } catch (...) {
47002       {
47003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47004       };
47005     }
47006   }
47007
47008   jresult = result;
47009   return jresult;
47010 }
47011
47012
47013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
47014   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47015   int arg2 ;
47016
47017   arg1 = (Dali::Rect< int > *)jarg1;
47018   arg2 = (int)jarg2;
47019   if (arg1) (arg1)->x = arg2;
47020 }
47021
47022
47023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
47024   int jresult ;
47025   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47026   int result;
47027
47028   arg1 = (Dali::Rect< int > *)jarg1;
47029   result = (int) ((arg1)->x);
47030   jresult = result;
47031   return jresult;
47032 }
47033
47034
47035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
47036   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47037   int arg2 ;
47038
47039   arg1 = (Dali::Rect< int > *)jarg1;
47040   arg2 = (int)jarg2;
47041   if (arg1) (arg1)->left = arg2;
47042 }
47043
47044
47045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
47046   int jresult ;
47047   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47048   int result;
47049
47050   arg1 = (Dali::Rect< int > *)jarg1;
47051   result = (int) ((arg1)->left);
47052   jresult = result;
47053   return jresult;
47054 }
47055
47056
47057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
47058   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47059   int arg2 ;
47060
47061   arg1 = (Dali::Rect< int > *)jarg1;
47062   arg2 = (int)jarg2;
47063   if (arg1) (arg1)->y = arg2;
47064 }
47065
47066
47067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
47068   int jresult ;
47069   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47070   int result;
47071
47072   arg1 = (Dali::Rect< int > *)jarg1;
47073   result = (int) ((arg1)->y);
47074   jresult = result;
47075   return jresult;
47076 }
47077
47078
47079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
47080   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47081   int arg2 ;
47082
47083   arg1 = (Dali::Rect< int > *)jarg1;
47084   arg2 = (int)jarg2;
47085   if (arg1) (arg1)->right = arg2;
47086 }
47087
47088
47089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
47090   int jresult ;
47091   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47092   int result;
47093
47094   arg1 = (Dali::Rect< int > *)jarg1;
47095   result = (int) ((arg1)->right);
47096   jresult = result;
47097   return jresult;
47098 }
47099
47100
47101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
47102   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47103   int arg2 ;
47104
47105   arg1 = (Dali::Rect< int > *)jarg1;
47106   arg2 = (int)jarg2;
47107   if (arg1) (arg1)->width = arg2;
47108 }
47109
47110
47111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
47112   int jresult ;
47113   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47114   int result;
47115
47116   arg1 = (Dali::Rect< int > *)jarg1;
47117   result = (int) ((arg1)->width);
47118   jresult = result;
47119   return jresult;
47120 }
47121
47122
47123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
47124   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47125   int arg2 ;
47126
47127   arg1 = (Dali::Rect< int > *)jarg1;
47128   arg2 = (int)jarg2;
47129   if (arg1) (arg1)->bottom = arg2;
47130 }
47131
47132
47133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
47134   int jresult ;
47135   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47136   int result;
47137
47138   arg1 = (Dali::Rect< int > *)jarg1;
47139   result = (int) ((arg1)->bottom);
47140   jresult = result;
47141   return jresult;
47142 }
47143
47144
47145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
47146   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47147   int arg2 ;
47148
47149   arg1 = (Dali::Rect< int > *)jarg1;
47150   arg2 = (int)jarg2;
47151   if (arg1) (arg1)->height = arg2;
47152 }
47153
47154
47155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
47156   int jresult ;
47157   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47158   int result;
47159
47160   arg1 = (Dali::Rect< int > *)jarg1;
47161   result = (int) ((arg1)->height);
47162   jresult = result;
47163   return jresult;
47164 }
47165
47166
47167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
47168   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47169   int arg2 ;
47170
47171   arg1 = (Dali::Rect< int > *)jarg1;
47172   arg2 = (int)jarg2;
47173   if (arg1) (arg1)->top = arg2;
47174 }
47175
47176
47177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
47178   int jresult ;
47179   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47180   int result;
47181
47182   arg1 = (Dali::Rect< int > *)jarg1;
47183   result = (int) ((arg1)->top);
47184   jresult = result;
47185   return jresult;
47186 }
47187
47188
47189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
47190   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47191
47192   arg1 = (Dali::Rect< int > *)jarg1;
47193   {
47194     try {
47195       delete arg1;
47196     } catch (std::out_of_range& e) {
47197       {
47198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47199       };
47200     } catch (std::exception& e) {
47201       {
47202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47203       };
47204     } catch (Dali::DaliException e) {
47205       {
47206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47207       };
47208     } catch (...) {
47209       {
47210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47211       };
47212     }
47213   }
47214
47215 }
47216
47217
47218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
47219   void * jresult ;
47220   Dali::Rect< float > *result = 0 ;
47221
47222   {
47223     try {
47224       result = (Dali::Rect< float > *)new Dali::Rect< float >();
47225     } catch (std::out_of_range& e) {
47226       {
47227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47228       };
47229     } catch (std::exception& e) {
47230       {
47231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47232       };
47233     } catch (Dali::DaliException e) {
47234       {
47235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47236       };
47237     } catch (...) {
47238       {
47239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47240       };
47241     }
47242   }
47243
47244   jresult = (void *)result;
47245   return jresult;
47246 }
47247
47248
47249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
47250   void * jresult ;
47251   float arg1 ;
47252   float arg2 ;
47253   float arg3 ;
47254   float arg4 ;
47255   Dali::Rect< float > *result = 0 ;
47256
47257   arg1 = (float)jarg1;
47258   arg2 = (float)jarg2;
47259   arg3 = (float)jarg4;
47260   arg4 = (float)jarg3;
47261   {
47262     try {
47263       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
47264     } catch (std::out_of_range& e) {
47265       {
47266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47267       };
47268     } catch (std::exception& e) {
47269       {
47270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47271       };
47272     } catch (Dali::DaliException e) {
47273       {
47274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47275       };
47276     } catch (...) {
47277       {
47278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47279       };
47280     }
47281   }
47282
47283   jresult = (void *)result;
47284   return jresult;
47285 }
47286
47287
47288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
47289   void * jresult ;
47290   Dali::Rect< float > *arg1 = 0 ;
47291   Dali::Rect< float > *result = 0 ;
47292
47293   arg1 = (Dali::Rect< float > *)jarg1;
47294   if (!arg1) {
47295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47296     return 0;
47297   }
47298   {
47299     try {
47300       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
47301     } catch (std::out_of_range& e) {
47302       {
47303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47304       };
47305     } catch (std::exception& e) {
47306       {
47307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47308       };
47309     } catch (Dali::DaliException e) {
47310       {
47311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47312       };
47313     } catch (...) {
47314       {
47315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47316       };
47317     }
47318   }
47319
47320   jresult = (void *)result;
47321   return jresult;
47322 }
47323
47324
47325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
47326   void * jresult ;
47327   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47328   Dali::Rect< float > *arg2 = 0 ;
47329   Dali::Rect< float > *result = 0 ;
47330
47331   arg1 = (Dali::Rect< float > *)jarg1;
47332   arg2 = (Dali::Rect< float > *)jarg2;
47333   if (!arg2) {
47334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47335     return 0;
47336   }
47337   {
47338     try {
47339       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
47340     } catch (std::out_of_range& e) {
47341       {
47342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47343       };
47344     } catch (std::exception& e) {
47345       {
47346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47347       };
47348     } catch (Dali::DaliException e) {
47349       {
47350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47351       };
47352     } catch (...) {
47353       {
47354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47355       };
47356     }
47357   }
47358
47359   jresult = (void *)result;
47360   return jresult;
47361 }
47362
47363
47364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
47365   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47366   float arg2 ;
47367   float arg3 ;
47368   float arg4 ;
47369   float arg5 ;
47370
47371   arg1 = (Dali::Rect< float > *)jarg1;
47372   arg2 = (float)jarg2;
47373   arg3 = (float)jarg3;
47374   arg4 = (float)jarg5;
47375   arg5 = (float)jarg4;
47376   {
47377     try {
47378       (arg1)->Set(arg2,arg3,arg4,arg5);
47379     } catch (std::out_of_range& e) {
47380       {
47381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47382       };
47383     } catch (std::exception& e) {
47384       {
47385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47386       };
47387     } catch (Dali::DaliException e) {
47388       {
47389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47390       };
47391     } catch (...) {
47392       {
47393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47394       };
47395     }
47396   }
47397
47398 }
47399
47400
47401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
47402   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47403   float arg2 ;
47404
47405   arg1 = (Dali::Rect< float > *)jarg1;
47406   arg2 = (float)jarg2;
47407   if (arg1) (arg1)->left = arg2;
47408 }
47409
47410
47411 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
47412   float jresult ;
47413   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47414   float result;
47415
47416   arg1 = (Dali::Rect< float > *)jarg1;
47417   result = (float) ((arg1)->left);
47418   jresult = result;
47419   return jresult;
47420 }
47421
47422
47423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
47424   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47425   float arg2 ;
47426
47427   arg1 = (Dali::Rect< float > *)jarg1;
47428   arg2 = (float)jarg2;
47429   if (arg1) (arg1)->left = arg2;
47430 }
47431
47432
47433 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
47434   float jresult ;
47435   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47436   float result;
47437
47438   arg1 = (Dali::Rect< float > *)jarg1;
47439   result = (float) ((arg1)->left);
47440   jresult = result;
47441   return jresult;
47442 }
47443
47444
47445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
47446   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47447   float arg2 ;
47448
47449   arg1 = (Dali::Rect< float > *)jarg1;
47450   arg2 = (float)jarg2;
47451   if (arg1) (arg1)->right = arg2;
47452 }
47453
47454
47455 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
47456   float jresult ;
47457   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47458   float result;
47459
47460   arg1 = (Dali::Rect< float > *)jarg1;
47461   result = (float) ((arg1)->right);
47462   jresult = result;
47463   return jresult;
47464 }
47465
47466
47467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
47468   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47469   float arg2 ;
47470
47471   arg1 = (Dali::Rect< float > *)jarg1;
47472   arg2 = (float)jarg2;
47473   if (arg1) (arg1)->right = arg2;
47474 }
47475
47476
47477 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
47478   float jresult ;
47479   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47480   float result;
47481
47482   arg1 = (Dali::Rect< float > *)jarg1;
47483   result = (float) ((arg1)->right);
47484   jresult = result;
47485   return jresult;
47486 }
47487
47488
47489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
47490   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47491   float arg2 ;
47492
47493   arg1 = (Dali::Rect< float > *)jarg1;
47494   arg2 = (float)jarg2;
47495   if (arg1) (arg1)->bottom = arg2;
47496 }
47497
47498
47499 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
47500   float jresult ;
47501   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47502   float result;
47503
47504   arg1 = (Dali::Rect< float > *)jarg1;
47505   result = (float) ((arg1)->bottom);
47506   jresult = result;
47507   return jresult;
47508 }
47509
47510
47511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
47512   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47513   float arg2 ;
47514
47515   arg1 = (Dali::Rect< float > *)jarg1;
47516   arg2 = (float)jarg2;
47517   if (arg1) (arg1)->top = arg2;
47518 }
47519
47520
47521 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
47522   float jresult ;
47523   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47524   float result;
47525
47526   arg1 = (Dali::Rect< float > *)jarg1;
47527   result = (float) ((arg1)->top);
47528   jresult = result;
47529   return jresult;
47530 }
47531
47532
47533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
47534   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47535
47536   arg1 = (Dali::Rect< float > *)jarg1;
47537   {
47538     try {
47539       delete arg1;
47540     } catch (std::out_of_range& e) {
47541       {
47542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47543       };
47544     } catch (std::exception& e) {
47545       {
47546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47547       };
47548     } catch (Dali::DaliException e) {
47549       {
47550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47551       };
47552     } catch (...) {
47553       {
47554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47555       };
47556     }
47557   }
47558
47559 }
47560
47561
47562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
47563   int jresult ;
47564   int result;
47565
47566   result = (int)Dali::Vector< int >::BaseType;
47567   jresult = (int)result;
47568   return jresult;
47569 }
47570
47571
47572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
47573   void * jresult ;
47574   Dali::Vector< int > *result = 0 ;
47575
47576   {
47577     try {
47578       result = (Dali::Vector< int > *)new Dali::Vector< int >();
47579     } catch (std::out_of_range& e) {
47580       {
47581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47582       };
47583     } catch (std::exception& e) {
47584       {
47585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47586       };
47587     } catch (Dali::DaliException e) {
47588       {
47589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47590       };
47591     } catch (...) {
47592       {
47593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47594       };
47595     }
47596   }
47597
47598   jresult = (void *)result;
47599   return jresult;
47600 }
47601
47602
47603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
47604   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47605
47606   arg1 = (Dali::Vector< int > *)jarg1;
47607   {
47608     try {
47609       delete arg1;
47610     } catch (std::out_of_range& e) {
47611       {
47612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47613       };
47614     } catch (std::exception& e) {
47615       {
47616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47617       };
47618     } catch (Dali::DaliException e) {
47619       {
47620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47621       };
47622     } catch (...) {
47623       {
47624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47625       };
47626     }
47627   }
47628
47629 }
47630
47631
47632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
47633   void * jresult ;
47634   Dali::Vector< int > *arg1 = 0 ;
47635   Dali::Vector< int > *result = 0 ;
47636
47637   arg1 = (Dali::Vector< int > *)jarg1;
47638   if (!arg1) {
47639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
47640     return 0;
47641   }
47642   {
47643     try {
47644       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
47645     } catch (std::out_of_range& e) {
47646       {
47647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47648       };
47649     } catch (std::exception& e) {
47650       {
47651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47652       };
47653     } catch (Dali::DaliException e) {
47654       {
47655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47656       };
47657     } catch (...) {
47658       {
47659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47660       };
47661     }
47662   }
47663
47664   jresult = (void *)result;
47665   return jresult;
47666 }
47667
47668
47669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
47670   void * jresult ;
47671   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47672   Dali::Vector< int > *arg2 = 0 ;
47673   Dali::Vector< int > *result = 0 ;
47674
47675   arg1 = (Dali::Vector< int > *)jarg1;
47676   arg2 = (Dali::Vector< int > *)jarg2;
47677   if (!arg2) {
47678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
47679     return 0;
47680   }
47681   {
47682     try {
47683       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
47684     } catch (std::out_of_range& e) {
47685       {
47686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47687       };
47688     } catch (std::exception& e) {
47689       {
47690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47691       };
47692     } catch (Dali::DaliException e) {
47693       {
47694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47695       };
47696     } catch (...) {
47697       {
47698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47699       };
47700     }
47701   }
47702
47703   jresult = (void *)result;
47704   return jresult;
47705 }
47706
47707
47708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
47709   void * jresult ;
47710   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47711   Dali::Vector< int >::Iterator result;
47712
47713   arg1 = (Dali::Vector< int > *)jarg1;
47714   {
47715     try {
47716       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
47717     } catch (std::out_of_range& e) {
47718       {
47719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47720       };
47721     } catch (std::exception& e) {
47722       {
47723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47724       };
47725     } catch (Dali::DaliException e) {
47726       {
47727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47728       };
47729     } catch (...) {
47730       {
47731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47732       };
47733     }
47734   }
47735
47736   jresult = (void *)result;
47737   return jresult;
47738 }
47739
47740
47741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
47742   void * jresult ;
47743   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47744   Dali::Vector< int >::Iterator result;
47745
47746   arg1 = (Dali::Vector< int > *)jarg1;
47747   {
47748     try {
47749       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
47750     } catch (std::out_of_range& e) {
47751       {
47752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47753       };
47754     } catch (std::exception& e) {
47755       {
47756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47757       };
47758     } catch (Dali::DaliException e) {
47759       {
47760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47761       };
47762     } catch (...) {
47763       {
47764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47765       };
47766     }
47767   }
47768
47769   jresult = (void *)result;
47770   return jresult;
47771 }
47772
47773
47774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47775   void * jresult ;
47776   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47777   Dali::Vector< int >::SizeType arg2 ;
47778   Dali::Vector< int >::ItemType *result = 0 ;
47779
47780   arg1 = (Dali::Vector< int > *)jarg1;
47781   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47782   {
47783     try {
47784       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
47785     } catch (std::out_of_range& e) {
47786       {
47787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47788       };
47789     } catch (std::exception& e) {
47790       {
47791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47792       };
47793     } catch (Dali::DaliException e) {
47794       {
47795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47796       };
47797     } catch (...) {
47798       {
47799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47800       };
47801     }
47802   }
47803
47804   jresult = (void *)result;
47805   return jresult;
47806 }
47807
47808
47809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
47810   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47811   Dali::Vector< int >::ItemType *arg2 = 0 ;
47812   Dali::Vector< int >::ItemType temp2 ;
47813
47814   arg1 = (Dali::Vector< int > *)jarg1;
47815   temp2 = (Dali::Vector< int >::ItemType)jarg2;
47816   arg2 = &temp2;
47817   {
47818     try {
47819       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
47820     } catch (std::out_of_range& e) {
47821       {
47822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47823       };
47824     } catch (std::exception& e) {
47825       {
47826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47827       };
47828     } catch (Dali::DaliException e) {
47829       {
47830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47831       };
47832     } catch (...) {
47833       {
47834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47835       };
47836     }
47837   }
47838
47839 }
47840
47841
47842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
47843   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47844   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
47845   Dali::Vector< int >::ItemType *arg3 = 0 ;
47846   Dali::Vector< int >::ItemType temp3 ;
47847
47848   arg1 = (Dali::Vector< int > *)jarg1;
47849   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47850   temp3 = (Dali::Vector< int >::ItemType)jarg3;
47851   arg3 = &temp3;
47852   {
47853     try {
47854       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
47855     } catch (std::out_of_range& e) {
47856       {
47857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47858       };
47859     } catch (std::exception& e) {
47860       {
47861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47862       };
47863     } catch (Dali::DaliException e) {
47864       {
47865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47866       };
47867     } catch (...) {
47868       {
47869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47870       };
47871     }
47872   }
47873
47874 }
47875
47876
47877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47878   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47879   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
47880   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
47881   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
47882
47883   arg1 = (Dali::Vector< int > *)jarg1;
47884   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47885   arg3 = (Dali::Vector< int >::Iterator)jarg3;
47886   arg4 = (Dali::Vector< int >::Iterator)jarg4;
47887   {
47888     try {
47889       (arg1)->Insert(arg2,arg3,arg4);
47890     } catch (std::out_of_range& e) {
47891       {
47892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47893       };
47894     } catch (std::exception& e) {
47895       {
47896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47897       };
47898     } catch (Dali::DaliException e) {
47899       {
47900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47901       };
47902     } catch (...) {
47903       {
47904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47905       };
47906     }
47907   }
47908
47909 }
47910
47911
47912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
47913   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47914   Dali::Vector< int >::SizeType arg2 ;
47915
47916   arg1 = (Dali::Vector< int > *)jarg1;
47917   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47918   {
47919     try {
47920       (arg1)->Reserve(arg2);
47921     } catch (std::out_of_range& e) {
47922       {
47923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47924       };
47925     } catch (std::exception& e) {
47926       {
47927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47928       };
47929     } catch (Dali::DaliException e) {
47930       {
47931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47932       };
47933     } catch (...) {
47934       {
47935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47936       };
47937     }
47938   }
47939
47940 }
47941
47942
47943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47944   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47945   Dali::Vector< int >::SizeType arg2 ;
47946
47947   arg1 = (Dali::Vector< int > *)jarg1;
47948   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47949   {
47950     try {
47951       (arg1)->Resize(arg2);
47952     } catch (std::out_of_range& e) {
47953       {
47954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47955       };
47956     } catch (std::exception& e) {
47957       {
47958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47959       };
47960     } catch (Dali::DaliException e) {
47961       {
47962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47963       };
47964     } catch (...) {
47965       {
47966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47967       };
47968     }
47969   }
47970
47971 }
47972
47973
47974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
47975   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47976   Dali::Vector< int >::SizeType arg2 ;
47977   Dali::Vector< int >::ItemType *arg3 = 0 ;
47978   Dali::Vector< int >::ItemType temp3 ;
47979
47980   arg1 = (Dali::Vector< int > *)jarg1;
47981   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47982   temp3 = (Dali::Vector< int >::ItemType)jarg3;
47983   arg3 = &temp3;
47984   {
47985     try {
47986       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
47987     } catch (std::out_of_range& e) {
47988       {
47989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47990       };
47991     } catch (std::exception& e) {
47992       {
47993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47994       };
47995     } catch (Dali::DaliException e) {
47996       {
47997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47998       };
47999     } catch (...) {
48000       {
48001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48002       };
48003     }
48004   }
48005
48006 }
48007
48008
48009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
48010   void * jresult ;
48011   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48012   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48013   Dali::Vector< int >::Iterator result;
48014
48015   arg1 = (Dali::Vector< int > *)jarg1;
48016   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48017   {
48018     try {
48019       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
48020     } catch (std::out_of_range& e) {
48021       {
48022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48023       };
48024     } catch (std::exception& e) {
48025       {
48026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48027       };
48028     } catch (Dali::DaliException e) {
48029       {
48030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48031       };
48032     } catch (...) {
48033       {
48034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48035       };
48036     }
48037   }
48038
48039   jresult = (void *)result;
48040   return jresult;
48041 }
48042
48043
48044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48045   void * jresult ;
48046   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48047   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48048   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48049   Dali::Vector< int >::Iterator result;
48050
48051   arg1 = (Dali::Vector< int > *)jarg1;
48052   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48053   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48054   {
48055     try {
48056       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
48057     } catch (std::out_of_range& e) {
48058       {
48059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48060       };
48061     } catch (std::exception& e) {
48062       {
48063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48064       };
48065     } catch (Dali::DaliException e) {
48066       {
48067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48068       };
48069     } catch (...) {
48070       {
48071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48072       };
48073     }
48074   }
48075
48076   jresult = (void *)result;
48077   return jresult;
48078 }
48079
48080
48081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
48082   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48083   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48084
48085   arg1 = (Dali::Vector< int > *)jarg1;
48086   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48087   {
48088     try {
48089       (arg1)->Remove(arg2);
48090     } catch (std::out_of_range& e) {
48091       {
48092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48093       };
48094     } catch (std::exception& e) {
48095       {
48096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48097       };
48098     } catch (Dali::DaliException e) {
48099       {
48100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48101       };
48102     } catch (...) {
48103       {
48104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48105       };
48106     }
48107   }
48108
48109 }
48110
48111
48112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
48113   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48114   Dali::Vector< int > *arg2 = 0 ;
48115
48116   arg1 = (Dali::Vector< int > *)jarg1;
48117   arg2 = (Dali::Vector< int > *)jarg2;
48118   if (!arg2) {
48119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
48120     return ;
48121   }
48122   {
48123     try {
48124       (arg1)->Swap(*arg2);
48125     } catch (std::out_of_range& e) {
48126       {
48127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48128       };
48129     } catch (std::exception& e) {
48130       {
48131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48132       };
48133     } catch (Dali::DaliException e) {
48134       {
48135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48136       };
48137     } catch (...) {
48138       {
48139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48140       };
48141     }
48142   }
48143
48144 }
48145
48146
48147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
48148   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48149
48150   arg1 = (Dali::Vector< int > *)jarg1;
48151   {
48152     try {
48153       (arg1)->Clear();
48154     } catch (std::out_of_range& e) {
48155       {
48156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48157       };
48158     } catch (std::exception& e) {
48159       {
48160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48161       };
48162     } catch (Dali::DaliException e) {
48163       {
48164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48165       };
48166     } catch (...) {
48167       {
48168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48169       };
48170     }
48171   }
48172
48173 }
48174
48175
48176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
48177   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48178
48179   arg1 = (Dali::Vector< int > *)jarg1;
48180   {
48181     try {
48182       (arg1)->Release();
48183     } catch (std::out_of_range& e) {
48184       {
48185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48186       };
48187     } catch (std::exception& e) {
48188       {
48189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48190       };
48191     } catch (Dali::DaliException e) {
48192       {
48193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48194       };
48195     } catch (...) {
48196       {
48197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48198       };
48199     }
48200   }
48201
48202 }
48203
48204
48205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
48206   int jresult ;
48207   int result;
48208
48209   result = (int)Dali::Vector< float >::BaseType;
48210   jresult = (int)result;
48211   return jresult;
48212 }
48213
48214
48215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
48216   void * jresult ;
48217   Dali::Vector< float > *result = 0 ;
48218
48219   {
48220     try {
48221       result = (Dali::Vector< float > *)new Dali::Vector< float >();
48222     } catch (std::out_of_range& e) {
48223       {
48224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48225       };
48226     } catch (std::exception& e) {
48227       {
48228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48229       };
48230     } catch (Dali::DaliException e) {
48231       {
48232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48233       };
48234     } catch (...) {
48235       {
48236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48237       };
48238     }
48239   }
48240
48241   jresult = (void *)result;
48242   return jresult;
48243 }
48244
48245
48246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
48247   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48248
48249   arg1 = (Dali::Vector< float > *)jarg1;
48250   {
48251     try {
48252       delete arg1;
48253     } catch (std::out_of_range& e) {
48254       {
48255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48256       };
48257     } catch (std::exception& e) {
48258       {
48259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48260       };
48261     } catch (Dali::DaliException e) {
48262       {
48263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48264       };
48265     } catch (...) {
48266       {
48267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48268       };
48269     }
48270   }
48271
48272 }
48273
48274
48275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
48276   void * jresult ;
48277   Dali::Vector< float > *arg1 = 0 ;
48278   Dali::Vector< float > *result = 0 ;
48279
48280   arg1 = (Dali::Vector< float > *)jarg1;
48281   if (!arg1) {
48282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48283     return 0;
48284   }
48285   {
48286     try {
48287       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
48288     } catch (std::out_of_range& e) {
48289       {
48290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48291       };
48292     } catch (std::exception& e) {
48293       {
48294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48295       };
48296     } catch (Dali::DaliException e) {
48297       {
48298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48299       };
48300     } catch (...) {
48301       {
48302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48303       };
48304     }
48305   }
48306
48307   jresult = (void *)result;
48308   return jresult;
48309 }
48310
48311
48312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
48313   void * jresult ;
48314   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48315   Dali::Vector< float > *arg2 = 0 ;
48316   Dali::Vector< float > *result = 0 ;
48317
48318   arg1 = (Dali::Vector< float > *)jarg1;
48319   arg2 = (Dali::Vector< float > *)jarg2;
48320   if (!arg2) {
48321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48322     return 0;
48323   }
48324   {
48325     try {
48326       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
48327     } catch (std::out_of_range& e) {
48328       {
48329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48330       };
48331     } catch (std::exception& e) {
48332       {
48333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48334       };
48335     } catch (Dali::DaliException e) {
48336       {
48337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48338       };
48339     } catch (...) {
48340       {
48341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48342       };
48343     }
48344   }
48345
48346   jresult = (void *)result;
48347   return jresult;
48348 }
48349
48350
48351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
48352   void * jresult ;
48353   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48354   Dali::Vector< float >::Iterator result;
48355
48356   arg1 = (Dali::Vector< float > *)jarg1;
48357   {
48358     try {
48359       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
48360     } catch (std::out_of_range& e) {
48361       {
48362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48363       };
48364     } catch (std::exception& e) {
48365       {
48366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48367       };
48368     } catch (Dali::DaliException e) {
48369       {
48370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48371       };
48372     } catch (...) {
48373       {
48374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48375       };
48376     }
48377   }
48378
48379   jresult = (void *)result;
48380   return jresult;
48381 }
48382
48383
48384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
48385   void * jresult ;
48386   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48387   Dali::Vector< float >::Iterator result;
48388
48389   arg1 = (Dali::Vector< float > *)jarg1;
48390   {
48391     try {
48392       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
48393     } catch (std::out_of_range& e) {
48394       {
48395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48396       };
48397     } catch (std::exception& e) {
48398       {
48399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48400       };
48401     } catch (Dali::DaliException e) {
48402       {
48403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48404       };
48405     } catch (...) {
48406       {
48407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48408       };
48409     }
48410   }
48411
48412   jresult = (void *)result;
48413   return jresult;
48414 }
48415
48416
48417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48418   void * jresult ;
48419   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48420   Dali::Vector< float >::SizeType arg2 ;
48421   Dali::Vector< float >::ItemType *result = 0 ;
48422
48423   arg1 = (Dali::Vector< float > *)jarg1;
48424   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48425   {
48426     try {
48427       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
48428     } catch (std::out_of_range& e) {
48429       {
48430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48431       };
48432     } catch (std::exception& e) {
48433       {
48434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48435       };
48436     } catch (Dali::DaliException e) {
48437       {
48438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48439       };
48440     } catch (...) {
48441       {
48442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48443       };
48444     }
48445   }
48446
48447   jresult = (void *)result;
48448   return jresult;
48449 }
48450
48451
48452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
48453   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48454   Dali::Vector< float >::ItemType *arg2 = 0 ;
48455   Dali::Vector< float >::ItemType temp2 ;
48456
48457   arg1 = (Dali::Vector< float > *)jarg1;
48458   temp2 = (Dali::Vector< float >::ItemType)jarg2;
48459   arg2 = &temp2;
48460   {
48461     try {
48462       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
48463     } catch (std::out_of_range& e) {
48464       {
48465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48466       };
48467     } catch (std::exception& e) {
48468       {
48469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48470       };
48471     } catch (Dali::DaliException e) {
48472       {
48473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48474       };
48475     } catch (...) {
48476       {
48477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48478       };
48479     }
48480   }
48481
48482 }
48483
48484
48485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
48486   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48487   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48488   Dali::Vector< float >::ItemType *arg3 = 0 ;
48489   Dali::Vector< float >::ItemType temp3 ;
48490
48491   arg1 = (Dali::Vector< float > *)jarg1;
48492   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48493   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48494   arg3 = &temp3;
48495   {
48496     try {
48497       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48498     } catch (std::out_of_range& e) {
48499       {
48500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48501       };
48502     } catch (std::exception& e) {
48503       {
48504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48505       };
48506     } catch (Dali::DaliException e) {
48507       {
48508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48509       };
48510     } catch (...) {
48511       {
48512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48513       };
48514     }
48515   }
48516
48517 }
48518
48519
48520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48521   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48522   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48523   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
48524   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
48525
48526   arg1 = (Dali::Vector< float > *)jarg1;
48527   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48528   arg3 = (Dali::Vector< float >::Iterator)jarg3;
48529   arg4 = (Dali::Vector< float >::Iterator)jarg4;
48530   {
48531     try {
48532       (arg1)->Insert(arg2,arg3,arg4);
48533     } catch (std::out_of_range& e) {
48534       {
48535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48536       };
48537     } catch (std::exception& e) {
48538       {
48539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48540       };
48541     } catch (Dali::DaliException e) {
48542       {
48543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48544       };
48545     } catch (...) {
48546       {
48547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48548       };
48549     }
48550   }
48551
48552 }
48553
48554
48555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
48556   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48557   Dali::Vector< float >::SizeType arg2 ;
48558
48559   arg1 = (Dali::Vector< float > *)jarg1;
48560   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48561   {
48562     try {
48563       (arg1)->Reserve(arg2);
48564     } catch (std::out_of_range& e) {
48565       {
48566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48567       };
48568     } catch (std::exception& e) {
48569       {
48570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48571       };
48572     } catch (Dali::DaliException e) {
48573       {
48574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48575       };
48576     } catch (...) {
48577       {
48578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48579       };
48580     }
48581   }
48582
48583 }
48584
48585 //// ========================= end of part 2 =============================
48586
48587 //// ========================== start part 3 ===============================
48588
48589
48590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48591   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48592   Dali::Vector< float >::SizeType arg2 ;
48593
48594   arg1 = (Dali::Vector< float > *)jarg1;
48595   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48596   {
48597     try {
48598       (arg1)->Resize(arg2);
48599     } catch (std::out_of_range& e) {
48600       {
48601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48602       };
48603     } catch (std::exception& e) {
48604       {
48605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48606       };
48607     } catch (Dali::DaliException e) {
48608       {
48609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48610       };
48611     } catch (...) {
48612       {
48613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48614       };
48615     }
48616   }
48617
48618 }
48619
48620
48621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
48622   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48623   Dali::Vector< float >::SizeType arg2 ;
48624   Dali::Vector< float >::ItemType *arg3 = 0 ;
48625   Dali::Vector< float >::ItemType temp3 ;
48626
48627   arg1 = (Dali::Vector< float > *)jarg1;
48628   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48629   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48630   arg3 = &temp3;
48631   {
48632     try {
48633       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48634     } catch (std::out_of_range& e) {
48635       {
48636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48637       };
48638     } catch (std::exception& e) {
48639       {
48640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48641       };
48642     } catch (Dali::DaliException e) {
48643       {
48644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48645       };
48646     } catch (...) {
48647       {
48648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48649       };
48650     }
48651   }
48652
48653 }
48654
48655
48656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
48657   void * jresult ;
48658   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48659   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48660   Dali::Vector< float >::Iterator result;
48661
48662   arg1 = (Dali::Vector< float > *)jarg1;
48663   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48664   {
48665     try {
48666       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
48667     } catch (std::out_of_range& e) {
48668       {
48669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48670       };
48671     } catch (std::exception& e) {
48672       {
48673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48674       };
48675     } catch (Dali::DaliException e) {
48676       {
48677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48678       };
48679     } catch (...) {
48680       {
48681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48682       };
48683     }
48684   }
48685
48686   jresult = (void *)result;
48687   return jresult;
48688 }
48689
48690
48691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48692   void * jresult ;
48693   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48694   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48695   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
48696   Dali::Vector< float >::Iterator result;
48697
48698   arg1 = (Dali::Vector< float > *)jarg1;
48699   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48700   arg3 = (Dali::Vector< float >::Iterator)jarg3;
48701   {
48702     try {
48703       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
48704     } catch (std::out_of_range& e) {
48705       {
48706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48707       };
48708     } catch (std::exception& e) {
48709       {
48710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48711       };
48712     } catch (Dali::DaliException e) {
48713       {
48714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48715       };
48716     } catch (...) {
48717       {
48718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48719       };
48720     }
48721   }
48722
48723   jresult = (void *)result;
48724   return jresult;
48725 }
48726
48727
48728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
48729   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48730   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48731
48732   arg1 = (Dali::Vector< float > *)jarg1;
48733   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48734   {
48735     try {
48736       (arg1)->Remove(arg2);
48737     } catch (std::out_of_range& e) {
48738       {
48739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48740       };
48741     } catch (std::exception& e) {
48742       {
48743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48744       };
48745     } catch (Dali::DaliException e) {
48746       {
48747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48748       };
48749     } catch (...) {
48750       {
48751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48752       };
48753     }
48754   }
48755
48756 }
48757
48758
48759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
48760   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48761   Dali::Vector< float > *arg2 = 0 ;
48762
48763   arg1 = (Dali::Vector< float > *)jarg1;
48764   arg2 = (Dali::Vector< float > *)jarg2;
48765   if (!arg2) {
48766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
48767     return ;
48768   }
48769   {
48770     try {
48771       (arg1)->Swap(*arg2);
48772     } catch (std::out_of_range& e) {
48773       {
48774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48775       };
48776     } catch (std::exception& e) {
48777       {
48778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48779       };
48780     } catch (Dali::DaliException e) {
48781       {
48782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48783       };
48784     } catch (...) {
48785       {
48786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48787       };
48788     }
48789   }
48790
48791 }
48792
48793
48794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
48795   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48796
48797   arg1 = (Dali::Vector< float > *)jarg1;
48798   {
48799     try {
48800       (arg1)->Clear();
48801     } catch (std::out_of_range& e) {
48802       {
48803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48804       };
48805     } catch (std::exception& e) {
48806       {
48807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48808       };
48809     } catch (Dali::DaliException e) {
48810       {
48811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48812       };
48813     } catch (...) {
48814       {
48815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48816       };
48817     }
48818   }
48819
48820 }
48821
48822
48823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
48824   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48825
48826   arg1 = (Dali::Vector< float > *)jarg1;
48827   {
48828     try {
48829       (arg1)->Release();
48830     } catch (std::out_of_range& e) {
48831       {
48832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48833       };
48834     } catch (std::exception& e) {
48835       {
48836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48837       };
48838     } catch (Dali::DaliException e) {
48839       {
48840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48841       };
48842     } catch (...) {
48843       {
48844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48845       };
48846     }
48847   }
48848
48849 }
48850
48851
48852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
48853   int jresult ;
48854   int result;
48855
48856   result = (int)Dali::Vector< unsigned char >::BaseType;
48857   jresult = (int)result;
48858   return jresult;
48859 }
48860
48861
48862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
48863   void * jresult ;
48864   Dali::Vector< unsigned char > *result = 0 ;
48865
48866   {
48867     try {
48868       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
48869     } catch (std::out_of_range& e) {
48870       {
48871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48872       };
48873     } catch (std::exception& e) {
48874       {
48875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48876       };
48877     } catch (Dali::DaliException e) {
48878       {
48879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48880       };
48881     } catch (...) {
48882       {
48883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48884       };
48885     }
48886   }
48887
48888   jresult = (void *)result;
48889   return jresult;
48890 }
48891
48892
48893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
48894   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48895
48896   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48897   {
48898     try {
48899       delete arg1;
48900     } catch (std::out_of_range& e) {
48901       {
48902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48903       };
48904     } catch (std::exception& e) {
48905       {
48906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48907       };
48908     } catch (Dali::DaliException e) {
48909       {
48910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48911       };
48912     } catch (...) {
48913       {
48914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48915       };
48916     }
48917   }
48918
48919 }
48920
48921
48922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
48923   void * jresult ;
48924   Dali::Vector< unsigned char > *arg1 = 0 ;
48925   Dali::Vector< unsigned char > *result = 0 ;
48926
48927   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48928   if (!arg1) {
48929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
48930     return 0;
48931   }
48932   {
48933     try {
48934       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
48935     } catch (std::out_of_range& e) {
48936       {
48937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48938       };
48939     } catch (std::exception& e) {
48940       {
48941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48942       };
48943     } catch (Dali::DaliException e) {
48944       {
48945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48946       };
48947     } catch (...) {
48948       {
48949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48950       };
48951     }
48952   }
48953
48954   jresult = (void *)result;
48955   return jresult;
48956 }
48957
48958
48959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
48960   void * jresult ;
48961   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48962   Dali::Vector< unsigned char > *arg2 = 0 ;
48963   Dali::Vector< unsigned char > *result = 0 ;
48964
48965   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48966   arg2 = (Dali::Vector< unsigned char > *)jarg2;
48967   if (!arg2) {
48968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
48969     return 0;
48970   }
48971   {
48972     try {
48973       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
48974     } catch (std::out_of_range& e) {
48975       {
48976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48977       };
48978     } catch (std::exception& e) {
48979       {
48980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48981       };
48982     } catch (Dali::DaliException e) {
48983       {
48984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48985       };
48986     } catch (...) {
48987       {
48988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48989       };
48990     }
48991   }
48992
48993   jresult = (void *)result;
48994   return jresult;
48995 }
48996
48997
48998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
48999   void * jresult ;
49000   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49001   Dali::Vector< unsigned char >::Iterator result;
49002
49003   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49004   {
49005     try {
49006       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
49007     } catch (std::out_of_range& e) {
49008       {
49009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49010       };
49011     } catch (std::exception& e) {
49012       {
49013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49014       };
49015     } catch (Dali::DaliException e) {
49016       {
49017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49018       };
49019     } catch (...) {
49020       {
49021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49022       };
49023     }
49024   }
49025
49026   jresult = (void *)result;
49027   return jresult;
49028 }
49029
49030
49031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
49032   void * jresult ;
49033   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49034   Dali::Vector< unsigned char >::Iterator result;
49035
49036   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49037   {
49038     try {
49039       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
49040     } catch (std::out_of_range& e) {
49041       {
49042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49043       };
49044     } catch (std::exception& e) {
49045       {
49046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49047       };
49048     } catch (Dali::DaliException e) {
49049       {
49050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49051       };
49052     } catch (...) {
49053       {
49054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49055       };
49056     }
49057   }
49058
49059   jresult = (void *)result;
49060   return jresult;
49061 }
49062
49063
49064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49065   void * jresult ;
49066   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49067   Dali::Vector< unsigned char >::SizeType arg2 ;
49068   Dali::Vector< unsigned char >::ItemType *result = 0 ;
49069
49070   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49071   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49072   {
49073     try {
49074       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
49075     } catch (std::out_of_range& e) {
49076       {
49077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49078       };
49079     } catch (std::exception& e) {
49080       {
49081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49082       };
49083     } catch (Dali::DaliException e) {
49084       {
49085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49086       };
49087     } catch (...) {
49088       {
49089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49090       };
49091     }
49092   }
49093
49094   jresult = (void *)result;
49095   return jresult;
49096 }
49097
49098
49099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
49100   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49101   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
49102   Dali::Vector< unsigned char >::ItemType temp2 ;
49103
49104   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49105   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
49106   arg2 = &temp2;
49107   {
49108     try {
49109       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
49110     } catch (std::out_of_range& e) {
49111       {
49112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49113       };
49114     } catch (std::exception& e) {
49115       {
49116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49117       };
49118     } catch (Dali::DaliException e) {
49119       {
49120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49121       };
49122     } catch (...) {
49123       {
49124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49125       };
49126     }
49127   }
49128
49129 }
49130
49131
49132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
49133   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49134   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49135   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49136   Dali::Vector< unsigned char >::ItemType temp3 ;
49137
49138   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49139   arg2 = jarg2;
49140   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49141   arg3 = &temp3;
49142   {
49143     try {
49144       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49145     } catch (std::out_of_range& e) {
49146       {
49147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49148       };
49149     } catch (std::exception& e) {
49150       {
49151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49152       };
49153     } catch (Dali::DaliException e) {
49154       {
49155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49156       };
49157     } catch (...) {
49158       {
49159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49160       };
49161     }
49162   }
49163
49164
49165
49166 }
49167
49168
49169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
49170   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49171   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49172   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49173   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49174
49175   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49176   arg2 = jarg2;
49177   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49178   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
49179   {
49180     try {
49181       (arg1)->Insert(arg2,arg3,arg4);
49182     } catch (std::out_of_range& e) {
49183       {
49184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49185       };
49186     } catch (std::exception& e) {
49187       {
49188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49189       };
49190     } catch (Dali::DaliException e) {
49191       {
49192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49193       };
49194     } catch (...) {
49195       {
49196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49197       };
49198     }
49199   }
49200
49201
49202
49203 }
49204
49205
49206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
49207   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49208   Dali::Vector< unsigned char >::SizeType arg2 ;
49209
49210   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49211   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49212   {
49213     try {
49214       (arg1)->Reserve(arg2);
49215     } catch (std::out_of_range& e) {
49216       {
49217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49218       };
49219     } catch (std::exception& e) {
49220       {
49221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49222       };
49223     } catch (Dali::DaliException e) {
49224       {
49225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49226       };
49227     } catch (...) {
49228       {
49229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49230       };
49231     }
49232   }
49233
49234 }
49235
49236
49237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49238   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49239   Dali::Vector< unsigned char >::SizeType arg2 ;
49240
49241   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49242   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49243   {
49244     try {
49245       (arg1)->Resize(arg2);
49246     } catch (std::out_of_range& e) {
49247       {
49248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49249       };
49250     } catch (std::exception& e) {
49251       {
49252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49253       };
49254     } catch (Dali::DaliException e) {
49255       {
49256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49257       };
49258     } catch (...) {
49259       {
49260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49261       };
49262     }
49263   }
49264
49265 }
49266
49267
49268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
49269   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49270   Dali::Vector< unsigned char >::SizeType arg2 ;
49271   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49272   Dali::Vector< unsigned char >::ItemType temp3 ;
49273
49274   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49275   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49276   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49277   arg3 = &temp3;
49278   {
49279     try {
49280       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49281     } catch (std::out_of_range& e) {
49282       {
49283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49284       };
49285     } catch (std::exception& e) {
49286       {
49287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49288       };
49289     } catch (Dali::DaliException e) {
49290       {
49291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49292       };
49293     } catch (...) {
49294       {
49295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49296       };
49297     }
49298   }
49299
49300 }
49301
49302
49303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
49304   void * jresult ;
49305   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49306   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49307   Dali::Vector< unsigned char >::Iterator result;
49308
49309   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49310   arg2 = jarg2;
49311   {
49312     try {
49313       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
49314     } catch (std::out_of_range& e) {
49315       {
49316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49317       };
49318     } catch (std::exception& e) {
49319       {
49320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49321       };
49322     } catch (Dali::DaliException e) {
49323       {
49324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49325       };
49326     } catch (...) {
49327       {
49328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49329       };
49330     }
49331   }
49332
49333   jresult = (void *)result;
49334
49335
49336   return jresult;
49337 }
49338
49339
49340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
49341   void * jresult ;
49342   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49343   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49344   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49345   Dali::Vector< unsigned char >::Iterator result;
49346
49347   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49348   arg2 = jarg2;
49349   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49350   {
49351     try {
49352       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
49353     } catch (std::out_of_range& e) {
49354       {
49355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49356       };
49357     } catch (std::exception& e) {
49358       {
49359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49360       };
49361     } catch (Dali::DaliException e) {
49362       {
49363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49364       };
49365     } catch (...) {
49366       {
49367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49368       };
49369     }
49370   }
49371
49372   jresult = (void *)result;
49373
49374
49375   return jresult;
49376 }
49377
49378
49379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
49380   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49381   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49382
49383   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49384   arg2 = jarg2;
49385   {
49386     try {
49387       (arg1)->Remove(arg2);
49388     } catch (std::out_of_range& e) {
49389       {
49390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49391       };
49392     } catch (std::exception& e) {
49393       {
49394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49395       };
49396     } catch (Dali::DaliException e) {
49397       {
49398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49399       };
49400     } catch (...) {
49401       {
49402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49403       };
49404     }
49405   }
49406
49407
49408
49409 }
49410
49411
49412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
49413   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49414   Dali::Vector< unsigned char > *arg2 = 0 ;
49415
49416   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49417   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49418   if (!arg2) {
49419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
49420     return ;
49421   }
49422   {
49423     try {
49424       (arg1)->Swap(*arg2);
49425     } catch (std::out_of_range& e) {
49426       {
49427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49428       };
49429     } catch (std::exception& e) {
49430       {
49431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49432       };
49433     } catch (Dali::DaliException e) {
49434       {
49435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49436       };
49437     } catch (...) {
49438       {
49439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49440       };
49441     }
49442   }
49443
49444 }
49445
49446
49447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
49448   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49449
49450   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49451   {
49452     try {
49453       (arg1)->Clear();
49454     } catch (std::out_of_range& e) {
49455       {
49456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49457       };
49458     } catch (std::exception& e) {
49459       {
49460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49461       };
49462     } catch (Dali::DaliException e) {
49463       {
49464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49465       };
49466     } catch (...) {
49467       {
49468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49469       };
49470     }
49471   }
49472
49473 }
49474
49475
49476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
49477   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49478
49479   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49480   {
49481     try {
49482       (arg1)->Release();
49483     } catch (std::out_of_range& e) {
49484       {
49485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49486       };
49487     } catch (std::exception& e) {
49488       {
49489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49490       };
49491     } catch (Dali::DaliException e) {
49492       {
49493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49494       };
49495     } catch (...) {
49496       {
49497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49498       };
49499     }
49500   }
49501
49502 }
49503
49504
49505 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
49506   int jresult ;
49507   int result;
49508
49509   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
49510   jresult = (int)result;
49511   return jresult;
49512 }
49513
49514
49515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
49516   void * jresult ;
49517   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49518
49519   {
49520     try {
49521       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
49522     } catch (std::out_of_range& e) {
49523       {
49524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49525       };
49526     } catch (std::exception& e) {
49527       {
49528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49529       };
49530     } catch (Dali::DaliException e) {
49531       {
49532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49533       };
49534     } catch (...) {
49535       {
49536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49537       };
49538     }
49539   }
49540
49541   jresult = (void *)result;
49542   return jresult;
49543 }
49544
49545
49546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
49547   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49548
49549   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49550   {
49551     try {
49552       delete arg1;
49553     } catch (std::out_of_range& e) {
49554       {
49555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49556       };
49557     } catch (std::exception& e) {
49558       {
49559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49560       };
49561     } catch (Dali::DaliException e) {
49562       {
49563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49564       };
49565     } catch (...) {
49566       {
49567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49568       };
49569     }
49570   }
49571
49572 }
49573
49574
49575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
49576   void * jresult ;
49577   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
49578   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49579
49580   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49581   if (!arg1) {
49582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49583     return 0;
49584   }
49585   {
49586     try {
49587       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
49588     } catch (std::out_of_range& e) {
49589       {
49590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49591       };
49592     } catch (std::exception& e) {
49593       {
49594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49595       };
49596     } catch (Dali::DaliException e) {
49597       {
49598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49599       };
49600     } catch (...) {
49601       {
49602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49603       };
49604     }
49605   }
49606
49607   jresult = (void *)result;
49608   return jresult;
49609 }
49610
49611
49612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
49613   void * jresult ;
49614   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49615   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
49616   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49617
49618   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49619   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
49620   if (!arg2) {
49621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49622     return 0;
49623   }
49624   {
49625     try {
49626       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
49627     } catch (std::out_of_range& e) {
49628       {
49629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49630       };
49631     } catch (std::exception& e) {
49632       {
49633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49634       };
49635     } catch (Dali::DaliException e) {
49636       {
49637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49638       };
49639     } catch (...) {
49640       {
49641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49642       };
49643     }
49644   }
49645
49646   jresult = (void *)result;
49647   return jresult;
49648 }
49649
49650
49651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
49652   void * jresult ;
49653   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49654   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49655
49656   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49657   {
49658     try {
49659       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
49660     } catch (std::out_of_range& e) {
49661       {
49662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49663       };
49664     } catch (std::exception& e) {
49665       {
49666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49667       };
49668     } catch (Dali::DaliException e) {
49669       {
49670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49671       };
49672     } catch (...) {
49673       {
49674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49675       };
49676     }
49677   }
49678
49679   jresult = (void *)result;
49680   return jresult;
49681 }
49682
49683
49684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
49685   void * jresult ;
49686   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49687   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49688
49689   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49690   {
49691     try {
49692       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
49693     } catch (std::out_of_range& e) {
49694       {
49695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49696       };
49697     } catch (std::exception& e) {
49698       {
49699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49700       };
49701     } catch (Dali::DaliException e) {
49702       {
49703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49704       };
49705     } catch (...) {
49706       {
49707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49708       };
49709     }
49710   }
49711
49712   jresult = (void *)result;
49713   return jresult;
49714 }
49715
49716
49717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49718   void * jresult ;
49719   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49720   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49721   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
49722
49723   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49724   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49725   {
49726     try {
49727       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
49728     } catch (std::out_of_range& e) {
49729       {
49730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49731       };
49732     } catch (std::exception& e) {
49733       {
49734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49735       };
49736     } catch (Dali::DaliException e) {
49737       {
49738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49739       };
49740     } catch (...) {
49741       {
49742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49743       };
49744     }
49745   }
49746
49747   jresult = (void *)result;
49748   return jresult;
49749 }
49750
49751
49752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
49753   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49754   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
49755
49756   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49757   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
49758   if (!arg2) {
49759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49760     return ;
49761   }
49762   {
49763     try {
49764       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
49765     } catch (std::out_of_range& e) {
49766       {
49767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49768       };
49769     } catch (std::exception& e) {
49770       {
49771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49772       };
49773     } catch (Dali::DaliException e) {
49774       {
49775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49776       };
49777     } catch (...) {
49778       {
49779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49780       };
49781     }
49782   }
49783
49784 }
49785
49786
49787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
49788   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49789   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49790   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
49791
49792   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49793   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49794   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
49795   if (!arg3) {
49796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49797     return ;
49798   }
49799   {
49800     try {
49801       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
49802     } catch (std::out_of_range& e) {
49803       {
49804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49805       };
49806     } catch (std::exception& e) {
49807       {
49808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49809       };
49810     } catch (Dali::DaliException e) {
49811       {
49812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49813       };
49814     } catch (...) {
49815       {
49816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49817       };
49818     }
49819   }
49820
49821 }
49822
49823
49824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
49825   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49826   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49827   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49828   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49829
49830   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49831   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49832   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
49833   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
49834   {
49835     try {
49836       (arg1)->Insert(arg2,arg3,arg4);
49837     } catch (std::out_of_range& e) {
49838       {
49839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49840       };
49841     } catch (std::exception& e) {
49842       {
49843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49844       };
49845     } catch (Dali::DaliException e) {
49846       {
49847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49848       };
49849     } catch (...) {
49850       {
49851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49852       };
49853     }
49854   }
49855
49856 }
49857
49858
49859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
49860   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49861   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49862
49863   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49864   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49865   {
49866     try {
49867       (arg1)->Reserve(arg2);
49868     } catch (std::out_of_range& e) {
49869       {
49870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49871       };
49872     } catch (std::exception& e) {
49873       {
49874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49875       };
49876     } catch (Dali::DaliException e) {
49877       {
49878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49879       };
49880     } catch (...) {
49881       {
49882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49883       };
49884     }
49885   }
49886
49887 }
49888
49889
49890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49891   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49892   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49893
49894   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49895   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49896   {
49897     try {
49898       (arg1)->Resize(arg2);
49899     } catch (std::out_of_range& e) {
49900       {
49901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49902       };
49903     } catch (std::exception& e) {
49904       {
49905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49906       };
49907     } catch (Dali::DaliException e) {
49908       {
49909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49910       };
49911     } catch (...) {
49912       {
49913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49914       };
49915     }
49916   }
49917
49918 }
49919
49920
49921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
49922   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49923   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49924   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
49925
49926   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49927   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49928   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
49929   if (!arg3) {
49930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49931     return ;
49932   }
49933   {
49934     try {
49935       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
49936     } catch (std::out_of_range& e) {
49937       {
49938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49939       };
49940     } catch (std::exception& e) {
49941       {
49942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49943       };
49944     } catch (Dali::DaliException e) {
49945       {
49946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49947       };
49948     } catch (...) {
49949       {
49950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49951       };
49952     }
49953   }
49954
49955 }
49956
49957
49958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
49959   void * jresult ;
49960   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49961   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49962   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49963
49964   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49965   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49966   {
49967     try {
49968       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
49969     } catch (std::out_of_range& e) {
49970       {
49971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49972       };
49973     } catch (std::exception& e) {
49974       {
49975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49976       };
49977     } catch (Dali::DaliException e) {
49978       {
49979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49980       };
49981     } catch (...) {
49982       {
49983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49984       };
49985     }
49986   }
49987
49988   jresult = (void *)result;
49989   return jresult;
49990 }
49991
49992
49993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
49994   void * jresult ;
49995   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49996   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49997   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49998   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49999
50000   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50001   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50002   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
50003   {
50004     try {
50005       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
50006     } catch (std::out_of_range& e) {
50007       {
50008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50009       };
50010     } catch (std::exception& e) {
50011       {
50012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50013       };
50014     } catch (Dali::DaliException e) {
50015       {
50016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50017       };
50018     } catch (...) {
50019       {
50020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50021       };
50022     }
50023   }
50024
50025   jresult = (void *)result;
50026   return jresult;
50027 }
50028
50029
50030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
50031   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50032   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50033
50034   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50035   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50036   {
50037     try {
50038       (arg1)->Remove(arg2);
50039     } catch (std::out_of_range& e) {
50040       {
50041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50042       };
50043     } catch (std::exception& e) {
50044       {
50045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50046       };
50047     } catch (Dali::DaliException e) {
50048       {
50049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50050       };
50051     } catch (...) {
50052       {
50053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50054       };
50055     }
50056   }
50057
50058 }
50059
50060
50061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
50062   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50063   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
50064
50065   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50066   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
50067   if (!arg2) {
50068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
50069     return ;
50070   }
50071   {
50072     try {
50073       (arg1)->Swap(*arg2);
50074     } catch (std::out_of_range& e) {
50075       {
50076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50077       };
50078     } catch (std::exception& e) {
50079       {
50080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50081       };
50082     } catch (Dali::DaliException e) {
50083       {
50084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50085       };
50086     } catch (...) {
50087       {
50088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50089       };
50090     }
50091   }
50092
50093 }
50094
50095
50096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
50097   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50098
50099   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50100   {
50101     try {
50102       (arg1)->Clear();
50103     } catch (std::out_of_range& e) {
50104       {
50105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50106       };
50107     } catch (std::exception& e) {
50108       {
50109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50110       };
50111     } catch (Dali::DaliException e) {
50112       {
50113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50114       };
50115     } catch (...) {
50116       {
50117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50118       };
50119     }
50120   }
50121
50122 }
50123
50124
50125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
50126   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50127
50128   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50129   {
50130     try {
50131       (arg1)->Release();
50132     } catch (std::out_of_range& e) {
50133       {
50134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50135       };
50136     } catch (std::exception& e) {
50137       {
50138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50139       };
50140     } catch (Dali::DaliException e) {
50141       {
50142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50143       };
50144     } catch (...) {
50145       {
50146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50147       };
50148     }
50149   }
50150
50151 }
50152
50153
50154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
50155   void * jresult ;
50156   Dali::Signal< void () > *result = 0 ;
50157
50158   {
50159     try {
50160       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
50161     } catch (std::out_of_range& e) {
50162       {
50163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50164       };
50165     } catch (std::exception& e) {
50166       {
50167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50168       };
50169     } catch (Dali::DaliException e) {
50170       {
50171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50172       };
50173     } catch (...) {
50174       {
50175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50176       };
50177     }
50178   }
50179
50180   jresult = (void *)result;
50181   return jresult;
50182 }
50183
50184
50185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
50186   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50187
50188   arg1 = (Dali::Signal< void () > *)jarg1;
50189   {
50190     try {
50191       delete arg1;
50192     } catch (std::out_of_range& e) {
50193       {
50194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50195       };
50196     } catch (std::exception& e) {
50197       {
50198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50199       };
50200     } catch (Dali::DaliException e) {
50201       {
50202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50203       };
50204     } catch (...) {
50205       {
50206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50207       };
50208     }
50209   }
50210
50211 }
50212
50213
50214 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
50215   unsigned int jresult ;
50216   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50217   bool result;
50218
50219   arg1 = (Dali::Signal< void () > *)jarg1;
50220   {
50221     try {
50222       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
50223     } catch (std::out_of_range& e) {
50224       {
50225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50226       };
50227     } catch (std::exception& e) {
50228       {
50229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50230       };
50231     } catch (Dali::DaliException e) {
50232       {
50233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50234       };
50235     } catch (...) {
50236       {
50237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50238       };
50239     }
50240   }
50241
50242   jresult = result;
50243   return jresult;
50244 }
50245
50246
50247 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
50248   unsigned long jresult ;
50249   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50250   std::size_t result;
50251
50252   arg1 = (Dali::Signal< void () > *)jarg1;
50253   {
50254     try {
50255       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
50256     } catch (std::out_of_range& e) {
50257       {
50258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50259       };
50260     } catch (std::exception& e) {
50261       {
50262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50263       };
50264     } catch (Dali::DaliException e) {
50265       {
50266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50267       };
50268     } catch (...) {
50269       {
50270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50271       };
50272     }
50273   }
50274
50275   jresult = (unsigned long)result;
50276   return jresult;
50277 }
50278
50279
50280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
50281   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50282   void (*arg2)() = (void (*)()) 0 ;
50283
50284   arg1 = (Dali::Signal< void () > *)jarg1;
50285   arg2 = (void (*)())jarg2;
50286   {
50287     try {
50288       (arg1)->Connect(arg2);
50289     } catch (std::out_of_range& e) {
50290       {
50291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50292       };
50293     } catch (std::exception& e) {
50294       {
50295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50296       };
50297     } catch (Dali::DaliException e) {
50298       {
50299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50300       };
50301     } catch (...) {
50302       {
50303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50304       };
50305     }
50306   }
50307
50308 }
50309
50310
50311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
50312   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50313   void (*arg2)() = (void (*)()) 0 ;
50314
50315   arg1 = (Dali::Signal< void () > *)jarg1;
50316   arg2 = (void (*)())jarg2;
50317   {
50318     try {
50319       (arg1)->Disconnect(arg2);
50320     } catch (std::out_of_range& e) {
50321       {
50322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50323       };
50324     } catch (std::exception& e) {
50325       {
50326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50327       };
50328     } catch (Dali::DaliException e) {
50329       {
50330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50331       };
50332     } catch (...) {
50333       {
50334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50335       };
50336     }
50337   }
50338
50339 }
50340
50341
50342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
50343   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50344   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
50345   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
50346
50347   arg1 = (Dali::Signal< void () > *)jarg1;
50348   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
50349   arg3 = (Dali::FunctorDelegate *)jarg3;
50350   {
50351     try {
50352       (arg1)->Connect(arg2,arg3);
50353     } catch (std::out_of_range& e) {
50354       {
50355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50356       };
50357     } catch (std::exception& e) {
50358       {
50359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50360       };
50361     } catch (Dali::DaliException e) {
50362       {
50363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50364       };
50365     } catch (...) {
50366       {
50367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50368       };
50369     }
50370   }
50371
50372 }
50373
50374
50375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
50376   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50377
50378   arg1 = (Dali::Signal< void () > *)jarg1;
50379   {
50380     try {
50381       (arg1)->Emit();
50382     } catch (std::out_of_range& e) {
50383       {
50384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50385       };
50386     } catch (std::exception& e) {
50387       {
50388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50389       };
50390     } catch (Dali::DaliException e) {
50391       {
50392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50393       };
50394     } catch (...) {
50395       {
50396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50397       };
50398     }
50399   }
50400
50401 }
50402
50403
50404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
50405   unsigned int jresult ;
50406   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50407   bool result;
50408
50409   arg1 = (Dali::Signal< void (float) > *)jarg1;
50410   {
50411     try {
50412       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
50413     } catch (std::out_of_range& e) {
50414       {
50415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50416       };
50417     } catch (std::exception& e) {
50418       {
50419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50420       };
50421     } catch (Dali::DaliException e) {
50422       {
50423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50424       };
50425     } catch (...) {
50426       {
50427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50428       };
50429     }
50430   }
50431
50432   jresult = result;
50433   return jresult;
50434 }
50435
50436
50437 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
50438   unsigned long jresult ;
50439   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50440   std::size_t result;
50441
50442   arg1 = (Dali::Signal< void (float) > *)jarg1;
50443   {
50444     try {
50445       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
50446     } catch (std::out_of_range& e) {
50447       {
50448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50449       };
50450     } catch (std::exception& e) {
50451       {
50452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50453       };
50454     } catch (Dali::DaliException e) {
50455       {
50456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50457       };
50458     } catch (...) {
50459       {
50460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50461       };
50462     }
50463   }
50464
50465   jresult = (unsigned long)result;
50466   return jresult;
50467 }
50468
50469
50470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
50471   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50472   void (*arg2)(float) = (void (*)(float)) 0 ;
50473
50474   arg1 = (Dali::Signal< void (float) > *)jarg1;
50475   arg2 = (void (*)(float))jarg2;
50476   {
50477     try {
50478       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
50479     } catch (std::out_of_range& e) {
50480       {
50481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50482       };
50483     } catch (std::exception& e) {
50484       {
50485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50486       };
50487     } catch (Dali::DaliException e) {
50488       {
50489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50490       };
50491     } catch (...) {
50492       {
50493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50494       };
50495     }
50496   }
50497
50498 }
50499
50500
50501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
50502   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50503   void (*arg2)(float) = (void (*)(float)) 0 ;
50504
50505   arg1 = (Dali::Signal< void (float) > *)jarg1;
50506   arg2 = (void (*)(float))jarg2;
50507   {
50508     try {
50509       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
50510     } catch (std::out_of_range& e) {
50511       {
50512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50513       };
50514     } catch (std::exception& e) {
50515       {
50516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50517       };
50518     } catch (Dali::DaliException e) {
50519       {
50520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50521       };
50522     } catch (...) {
50523       {
50524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50525       };
50526     }
50527   }
50528
50529 }
50530
50531
50532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
50533   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50534   float arg2 ;
50535
50536   arg1 = (Dali::Signal< void (float) > *)jarg1;
50537   arg2 = (float)jarg2;
50538   {
50539     try {
50540       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
50541     } catch (std::out_of_range& e) {
50542       {
50543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50544       };
50545     } catch (std::exception& e) {
50546       {
50547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50548       };
50549     } catch (Dali::DaliException e) {
50550       {
50551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50552       };
50553     } catch (...) {
50554       {
50555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50556       };
50557     }
50558   }
50559
50560 }
50561
50562
50563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
50564   void * jresult ;
50565   Dali::Signal< void (float) > *result = 0 ;
50566
50567   {
50568     try {
50569       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
50570     } catch (std::out_of_range& e) {
50571       {
50572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50573       };
50574     } catch (std::exception& e) {
50575       {
50576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50577       };
50578     } catch (Dali::DaliException e) {
50579       {
50580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50581       };
50582     } catch (...) {
50583       {
50584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50585       };
50586     }
50587   }
50588
50589   jresult = (void *)result;
50590   return jresult;
50591 }
50592
50593
50594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
50595   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50596
50597   arg1 = (Dali::Signal< void (float) > *)jarg1;
50598   {
50599     try {
50600       delete arg1;
50601     } catch (std::out_of_range& e) {
50602       {
50603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50604       };
50605     } catch (std::exception& e) {
50606       {
50607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50608       };
50609     } catch (Dali::DaliException e) {
50610       {
50611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50612       };
50613     } catch (...) {
50614       {
50615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50616       };
50617     }
50618   }
50619
50620 }
50621
50622
50623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
50624   unsigned int jresult ;
50625   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50626   bool result;
50627
50628   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50629   {
50630     try {
50631       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50632     } catch (std::out_of_range& e) {
50633       {
50634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50635       };
50636     } catch (std::exception& e) {
50637       {
50638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50639       };
50640     } catch (Dali::DaliException e) {
50641       {
50642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50643       };
50644     } catch (...) {
50645       {
50646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50647       };
50648     }
50649   }
50650
50651   jresult = result;
50652   return jresult;
50653 }
50654
50655
50656 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
50657   unsigned long jresult ;
50658   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50659   std::size_t result;
50660
50661   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50662   {
50663     try {
50664       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50665     } catch (std::out_of_range& e) {
50666       {
50667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50668       };
50669     } catch (std::exception& e) {
50670       {
50671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50672       };
50673     } catch (Dali::DaliException e) {
50674       {
50675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50676       };
50677     } catch (...) {
50678       {
50679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50680       };
50681     }
50682   }
50683
50684   jresult = (unsigned long)result;
50685   return jresult;
50686 }
50687
50688
50689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
50690   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50691   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
50692
50693   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50694   arg2 = (void (*)(Dali::BaseHandle))jarg2;
50695   {
50696     try {
50697       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
50698     } catch (std::out_of_range& e) {
50699       {
50700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50701       };
50702     } catch (std::exception& e) {
50703       {
50704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50705       };
50706     } catch (Dali::DaliException e) {
50707       {
50708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50709       };
50710     } catch (...) {
50711       {
50712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50713       };
50714     }
50715   }
50716
50717 }
50718
50719
50720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
50721   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50722   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
50723
50724   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50725   arg2 = (void (*)(Dali::BaseHandle))jarg2;
50726   {
50727     try {
50728       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
50729     } catch (std::out_of_range& e) {
50730       {
50731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50732       };
50733     } catch (std::exception& e) {
50734       {
50735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50736       };
50737     } catch (Dali::DaliException e) {
50738       {
50739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50740       };
50741     } catch (...) {
50742       {
50743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50744       };
50745     }
50746   }
50747
50748 }
50749
50750
50751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
50752   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50753   Dali::BaseHandle arg2 ;
50754   Dali::BaseHandle *argp2 ;
50755
50756   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50757   argp2 = (Dali::BaseHandle *)jarg2;
50758   if (!argp2) {
50759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50760     return ;
50761   }
50762   arg2 = *argp2;
50763   {
50764     try {
50765       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
50766     } catch (std::out_of_range& e) {
50767       {
50768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50769       };
50770     } catch (std::exception& e) {
50771       {
50772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50773       };
50774     } catch (Dali::DaliException e) {
50775       {
50776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50777       };
50778     } catch (...) {
50779       {
50780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50781       };
50782     }
50783   }
50784
50785 }
50786
50787
50788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
50789   void * jresult ;
50790   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
50791
50792   {
50793     try {
50794       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
50795     } catch (std::out_of_range& e) {
50796       {
50797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50798       };
50799     } catch (std::exception& e) {
50800       {
50801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50802       };
50803     } catch (Dali::DaliException e) {
50804       {
50805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50806       };
50807     } catch (...) {
50808       {
50809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50810       };
50811     }
50812   }
50813
50814   jresult = (void *)result;
50815   return jresult;
50816 }
50817
50818
50819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
50820   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50821
50822   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50823   {
50824     try {
50825       delete arg1;
50826     } catch (std::out_of_range& e) {
50827       {
50828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50829       };
50830     } catch (std::exception& e) {
50831       {
50832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50833       };
50834     } catch (Dali::DaliException e) {
50835       {
50836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50837       };
50838     } catch (...) {
50839       {
50840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50841       };
50842     }
50843   }
50844
50845 }
50846
50847
50848 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
50849   unsigned int jresult ;
50850   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50851   bool result;
50852
50853   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50854   {
50855     try {
50856       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
50857     } catch (std::out_of_range& e) {
50858       {
50859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50860       };
50861     } catch (std::exception& e) {
50862       {
50863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50864       };
50865     } catch (Dali::DaliException e) {
50866       {
50867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50868       };
50869     } catch (...) {
50870       {
50871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50872       };
50873     }
50874   }
50875
50876   jresult = result;
50877   return jresult;
50878 }
50879
50880
50881 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
50882   unsigned long jresult ;
50883   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50884   std::size_t result;
50885
50886   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50887   {
50888     try {
50889       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
50890     } catch (std::out_of_range& e) {
50891       {
50892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50893       };
50894     } catch (std::exception& e) {
50895       {
50896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50897       };
50898     } catch (Dali::DaliException e) {
50899       {
50900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50901       };
50902     } catch (...) {
50903       {
50904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50905       };
50906     }
50907   }
50908
50909   jresult = (unsigned long)result;
50910   return jresult;
50911 }
50912
50913
50914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
50915   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50916   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
50917
50918   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50919   arg2 = (void (*)(Dali::RefObject const *))jarg2;
50920   {
50921     try {
50922       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
50923     } catch (std::out_of_range& e) {
50924       {
50925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50926       };
50927     } catch (std::exception& e) {
50928       {
50929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50930       };
50931     } catch (Dali::DaliException e) {
50932       {
50933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50934       };
50935     } catch (...) {
50936       {
50937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50938       };
50939     }
50940   }
50941
50942 }
50943
50944
50945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
50946   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50947   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
50948
50949   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50950   arg2 = (void (*)(Dali::RefObject const *))jarg2;
50951   {
50952     try {
50953       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
50954     } catch (std::out_of_range& e) {
50955       {
50956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50957       };
50958     } catch (std::exception& e) {
50959       {
50960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50961       };
50962     } catch (Dali::DaliException e) {
50963       {
50964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50965       };
50966     } catch (...) {
50967       {
50968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50969       };
50970     }
50971   }
50972
50973 }
50974
50975
50976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
50977   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50978   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
50979
50980   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50981   arg2 = (Dali::RefObject *)jarg2;
50982   {
50983     try {
50984       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
50985     } catch (std::out_of_range& e) {
50986       {
50987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50988       };
50989     } catch (std::exception& e) {
50990       {
50991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50992       };
50993     } catch (Dali::DaliException e) {
50994       {
50995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50996       };
50997     } catch (...) {
50998       {
50999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51000       };
51001     }
51002   }
51003
51004 }
51005
51006
51007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
51008   void * jresult ;
51009   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
51010
51011   {
51012     try {
51013       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
51014     } catch (std::out_of_range& e) {
51015       {
51016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51017       };
51018     } catch (std::exception& e) {
51019       {
51020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51021       };
51022     } catch (Dali::DaliException e) {
51023       {
51024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51025       };
51026     } catch (...) {
51027       {
51028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51029       };
51030     }
51031   }
51032
51033   jresult = (void *)result;
51034   return jresult;
51035 }
51036
51037
51038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
51039   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51040
51041   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51042   {
51043     try {
51044       delete arg1;
51045     } catch (std::out_of_range& e) {
51046       {
51047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51048       };
51049     } catch (std::exception& e) {
51050       {
51051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51052       };
51053     } catch (Dali::DaliException e) {
51054       {
51055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51056       };
51057     } catch (...) {
51058       {
51059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51060       };
51061     }
51062   }
51063
51064 }
51065
51066
51067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
51068   unsigned int jresult ;
51069   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51070   bool result;
51071
51072   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51073   {
51074     try {
51075       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51076     } catch (std::out_of_range& e) {
51077       {
51078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51079       };
51080     } catch (std::exception& e) {
51081       {
51082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51083       };
51084     } catch (Dali::DaliException e) {
51085       {
51086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51087       };
51088     } catch (...) {
51089       {
51090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51091       };
51092     }
51093   }
51094
51095   jresult = result;
51096   return jresult;
51097 }
51098
51099
51100 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
51101   unsigned long jresult ;
51102   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51103   std::size_t result;
51104
51105   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51106   {
51107     try {
51108       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51109     } catch (std::out_of_range& e) {
51110       {
51111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51112       };
51113     } catch (std::exception& e) {
51114       {
51115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51116       };
51117     } catch (Dali::DaliException e) {
51118       {
51119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51120       };
51121     } catch (...) {
51122       {
51123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51124       };
51125     }
51126   }
51127
51128   jresult = (unsigned long)result;
51129   return jresult;
51130 }
51131
51132
51133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
51134   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51135   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51136
51137   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51138   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51139   {
51140     try {
51141       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
51142     } catch (std::out_of_range& e) {
51143       {
51144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51145       };
51146     } catch (std::exception& e) {
51147       {
51148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51149       };
51150     } catch (Dali::DaliException e) {
51151       {
51152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51153       };
51154     } catch (...) {
51155       {
51156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51157       };
51158     }
51159   }
51160
51161 }
51162
51163
51164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
51165   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51166   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51167
51168   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51169   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51170   {
51171     try {
51172       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
51173     } catch (std::out_of_range& e) {
51174       {
51175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51176       };
51177     } catch (std::exception& e) {
51178       {
51179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51180       };
51181     } catch (Dali::DaliException e) {
51182       {
51183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51184       };
51185     } catch (...) {
51186       {
51187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51188       };
51189     }
51190   }
51191
51192 }
51193
51194
51195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
51196   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51197   Dali::PropertyNotification *arg2 = 0 ;
51198
51199   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51200   arg2 = (Dali::PropertyNotification *)jarg2;
51201   if (!arg2) {
51202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
51203     return ;
51204   }
51205   {
51206     try {
51207       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
51208     } catch (std::out_of_range& e) {
51209       {
51210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51211       };
51212     } catch (std::exception& e) {
51213       {
51214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51215       };
51216     } catch (Dali::DaliException e) {
51217       {
51218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51219       };
51220     } catch (...) {
51221       {
51222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51223       };
51224     }
51225   }
51226
51227 }
51228
51229
51230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
51231   void * jresult ;
51232   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
51233
51234   {
51235     try {
51236       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
51237     } catch (std::out_of_range& e) {
51238       {
51239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51240       };
51241     } catch (std::exception& e) {
51242       {
51243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51244       };
51245     } catch (Dali::DaliException e) {
51246       {
51247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51248       };
51249     } catch (...) {
51250       {
51251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51252       };
51253     }
51254   }
51255
51256   jresult = (void *)result;
51257   return jresult;
51258 }
51259
51260
51261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
51262   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51263
51264   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51265   {
51266     try {
51267       delete arg1;
51268     } catch (std::out_of_range& e) {
51269       {
51270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51271       };
51272     } catch (std::exception& e) {
51273       {
51274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51275       };
51276     } catch (Dali::DaliException e) {
51277       {
51278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51279       };
51280     } catch (...) {
51281       {
51282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51283       };
51284     }
51285   }
51286
51287 }
51288
51289
51290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
51291   void * jresult ;
51292   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
51293
51294   {
51295     try {
51296       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
51297     } catch (std::out_of_range& e) {
51298       {
51299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51300       };
51301     } catch (std::exception& e) {
51302       {
51303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51304       };
51305     } catch (Dali::DaliException e) {
51306       {
51307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51308       };
51309     } catch (...) {
51310       {
51311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51312       };
51313     }
51314   }
51315
51316   jresult = (void *)result;
51317   return jresult;
51318 }
51319
51320
51321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
51322   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
51323
51324   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
51325   {
51326     try {
51327       delete arg1;
51328     } catch (std::out_of_range& e) {
51329       {
51330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51331       };
51332     } catch (std::exception& e) {
51333       {
51334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51335       };
51336     } catch (Dali::DaliException e) {
51337       {
51338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51339       };
51340     } catch (...) {
51341       {
51342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51343       };
51344     }
51345   }
51346
51347 }
51348
51349
51350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
51351   unsigned int jresult ;
51352   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51353   bool result;
51354
51355   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51356   {
51357     try {
51358       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);
51359     } catch (std::out_of_range& e) {
51360       {
51361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51362       };
51363     } catch (std::exception& e) {
51364       {
51365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51366       };
51367     } catch (Dali::DaliException e) {
51368       {
51369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51370       };
51371     } catch (...) {
51372       {
51373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51374       };
51375     }
51376   }
51377
51378   jresult = result;
51379   return jresult;
51380 }
51381
51382
51383 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51384   unsigned long jresult ;
51385   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51386   std::size_t result;
51387
51388   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51389   {
51390     try {
51391       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);
51392     } catch (std::out_of_range& e) {
51393       {
51394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51395       };
51396     } catch (std::exception& e) {
51397       {
51398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51399       };
51400     } catch (Dali::DaliException e) {
51401       {
51402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51403       };
51404     } catch (...) {
51405       {
51406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51407       };
51408     }
51409   }
51410
51411   jresult = (unsigned long)result;
51412   return jresult;
51413 }
51414
51415
51416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51417   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51418   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51419
51420   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51421   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51422   {
51423     try {
51424       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51425     } catch (std::out_of_range& e) {
51426       {
51427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51428       };
51429     } catch (std::exception& e) {
51430       {
51431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51432       };
51433     } catch (Dali::DaliException e) {
51434       {
51435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51436       };
51437     } catch (...) {
51438       {
51439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51440       };
51441     }
51442   }
51443
51444 }
51445
51446
51447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51448   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51449   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51450
51451   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51452   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51453   {
51454     try {
51455       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51456     } catch (std::out_of_range& e) {
51457       {
51458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51459       };
51460     } catch (std::exception& e) {
51461       {
51462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51463       };
51464     } catch (Dali::DaliException e) {
51465       {
51466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51467       };
51468     } catch (...) {
51469       {
51470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51471       };
51472     }
51473   }
51474
51475 }
51476
51477
51478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51479   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51480   Dali::Actor arg2 ;
51481   Dali::LongPressGesture *arg3 = 0 ;
51482   Dali::Actor *argp2 ;
51483
51484   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51485   argp2 = (Dali::Actor *)jarg2;
51486   if (!argp2) {
51487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51488     return ;
51489   }
51490   arg2 = *argp2;
51491   arg3 = (Dali::LongPressGesture *)jarg3;
51492   if (!arg3) {
51493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
51494     return ;
51495   }
51496   {
51497     try {
51498       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
51499     } catch (std::out_of_range& e) {
51500       {
51501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51502       };
51503     } catch (std::exception& e) {
51504       {
51505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51506       };
51507     } catch (Dali::DaliException e) {
51508       {
51509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51510       };
51511     } catch (...) {
51512       {
51513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51514       };
51515     }
51516   }
51517
51518 }
51519
51520
51521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
51522   void * jresult ;
51523   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
51524
51525   {
51526     try {
51527       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
51528     } catch (std::out_of_range& e) {
51529       {
51530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51531       };
51532     } catch (std::exception& e) {
51533       {
51534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51535       };
51536     } catch (Dali::DaliException e) {
51537       {
51538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51539       };
51540     } catch (...) {
51541       {
51542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51543       };
51544     }
51545   }
51546
51547   jresult = (void *)result;
51548   return jresult;
51549 }
51550
51551
51552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
51553   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51554
51555   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51556   {
51557     try {
51558       delete arg1;
51559     } catch (std::out_of_range& e) {
51560       {
51561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51562       };
51563     } catch (std::exception& e) {
51564       {
51565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51566       };
51567     } catch (Dali::DaliException e) {
51568       {
51569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51570       };
51571     } catch (...) {
51572       {
51573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51574       };
51575     }
51576   }
51577
51578 }
51579
51580
51581 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
51582   unsigned int jresult ;
51583   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51584   bool result;
51585
51586   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51587   {
51588     try {
51589       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *)arg1);
51590     } catch (std::out_of_range& e) {
51591       {
51592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51593       };
51594     } catch (std::exception& e) {
51595       {
51596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51597       };
51598     } catch (Dali::DaliException e) {
51599       {
51600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51601       };
51602     } catch (...) {
51603       {
51604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51605       };
51606     }
51607   }
51608
51609   jresult = result;
51610   return jresult;
51611 }
51612
51613
51614 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
51615   unsigned long jresult ;
51616   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51617   std::size_t result;
51618
51619   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51620   {
51621     try {
51622       result = Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *)arg1);
51623     } catch (std::out_of_range& e) {
51624       {
51625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51626       };
51627     } catch (std::exception& e) {
51628       {
51629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51630       };
51631     } catch (Dali::DaliException e) {
51632       {
51633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51634       };
51635     } catch (...) {
51636       {
51637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51638       };
51639     }
51640   }
51641
51642   jresult = (unsigned long)result;
51643   return jresult;
51644 }
51645
51646
51647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
51648   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51649   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
51650
51651   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51652   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
51653   {
51654     try {
51655       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51656     } catch (std::out_of_range& e) {
51657       {
51658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51659       };
51660     } catch (std::exception& e) {
51661       {
51662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51663       };
51664     } catch (Dali::DaliException e) {
51665       {
51666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51667       };
51668     } catch (...) {
51669       {
51670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51671       };
51672     }
51673   }
51674
51675 }
51676
51677
51678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
51679   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51680   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
51681
51682   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51683   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
51684   {
51685     try {
51686       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51687     } catch (std::out_of_range& e) {
51688       {
51689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51690       };
51691     } catch (std::exception& e) {
51692       {
51693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51694       };
51695     } catch (Dali::DaliException e) {
51696       {
51697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51698       };
51699     } catch (...) {
51700       {
51701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51702       };
51703     }
51704   }
51705
51706 }
51707
51708
51709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51710   unsigned int jresult ;
51711   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51712   Dali::Actor arg2 ;
51713   Dali::TouchData *arg3 = 0 ;
51714   Dali::Actor *argp2 ;
51715   bool result;
51716
51717   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51718   argp2 = (Dali::Actor *)jarg2;
51719   if (!argp2) {
51720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51721     return 0;
51722   }
51723   arg2 = *argp2;
51724   arg3 = (Dali::TouchData *)jarg3;
51725   if (!arg3) {
51726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
51727     return 0;
51728   }
51729   {
51730     try {
51731       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
51732     } catch (std::out_of_range& e) {
51733       {
51734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51735       };
51736     } catch (std::exception& e) {
51737       {
51738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51739       };
51740     } catch (Dali::DaliException e) {
51741       {
51742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51743       };
51744     } catch (...) {
51745       {
51746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51747       };
51748     }
51749   }
51750
51751   jresult = result;
51752   return jresult;
51753 }
51754
51755
51756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
51757   void * jresult ;
51758   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
51759
51760   {
51761     try {
51762       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
51763     } catch (std::out_of_range& e) {
51764       {
51765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51766       };
51767     } catch (std::exception& e) {
51768       {
51769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51770       };
51771     } catch (Dali::DaliException e) {
51772       {
51773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51774       };
51775     } catch (...) {
51776       {
51777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51778       };
51779     }
51780   }
51781
51782   jresult = (void *)result;
51783   return jresult;
51784 }
51785
51786
51787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
51788   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51789
51790   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51791   {
51792     try {
51793       delete arg1;
51794     } catch (std::out_of_range& e) {
51795       {
51796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51797       };
51798     } catch (std::exception& e) {
51799       {
51800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51801       };
51802     } catch (Dali::DaliException e) {
51803       {
51804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51805       };
51806     } catch (...) {
51807       {
51808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51809       };
51810     }
51811   }
51812
51813 }
51814
51815
51816 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
51817   unsigned int jresult ;
51818   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51819   bool result;
51820
51821   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51822   {
51823     try {
51824       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);
51825     } catch (std::out_of_range& e) {
51826       {
51827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51828       };
51829     } catch (std::exception& e) {
51830       {
51831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51832       };
51833     } catch (Dali::DaliException e) {
51834       {
51835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51836       };
51837     } catch (...) {
51838       {
51839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51840       };
51841     }
51842   }
51843
51844   jresult = result;
51845   return jresult;
51846 }
51847
51848
51849 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
51850   unsigned long jresult ;
51851   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51852   std::size_t result;
51853
51854   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51855   {
51856     try {
51857       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);
51858     } catch (std::out_of_range& e) {
51859       {
51860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51861       };
51862     } catch (std::exception& e) {
51863       {
51864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51865       };
51866     } catch (Dali::DaliException e) {
51867       {
51868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51869       };
51870     } catch (...) {
51871       {
51872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51873       };
51874     }
51875   }
51876
51877   jresult = (unsigned long)result;
51878   return jresult;
51879 }
51880
51881
51882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
51883   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51884   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
51885
51886   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51887   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
51888   {
51889     try {
51890       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51891     } catch (std::out_of_range& e) {
51892       {
51893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51894       };
51895     } catch (std::exception& e) {
51896       {
51897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51898       };
51899     } catch (Dali::DaliException e) {
51900       {
51901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51902       };
51903     } catch (...) {
51904       {
51905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51906       };
51907     }
51908   }
51909
51910 }
51911
51912
51913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
51914   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51915   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
51916
51917   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51918   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
51919   {
51920     try {
51921       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51922     } catch (std::out_of_range& e) {
51923       {
51924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51925       };
51926     } catch (std::exception& e) {
51927       {
51928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51929       };
51930     } catch (Dali::DaliException e) {
51931       {
51932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51933       };
51934     } catch (...) {
51935       {
51936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51937       };
51938     }
51939   }
51940
51941 }
51942
51943
51944 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51945   unsigned int jresult ;
51946   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51947   Dali::Actor arg2 ;
51948   Dali::HoverEvent *arg3 = 0 ;
51949   Dali::Actor *argp2 ;
51950   bool result;
51951
51952   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51953   argp2 = (Dali::Actor *)jarg2;
51954   if (!argp2) {
51955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51956     return 0;
51957   }
51958   arg2 = *argp2;
51959   arg3 = (Dali::HoverEvent *)jarg3;
51960   if (!arg3) {
51961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
51962     return 0;
51963   }
51964   {
51965     try {
51966       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
51967     } catch (std::out_of_range& e) {
51968       {
51969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51970       };
51971     } catch (std::exception& e) {
51972       {
51973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51974       };
51975     } catch (Dali::DaliException e) {
51976       {
51977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51978       };
51979     } catch (...) {
51980       {
51981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51982       };
51983     }
51984   }
51985
51986   jresult = result;
51987   return jresult;
51988 }
51989
51990
51991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
51992   void * jresult ;
51993   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
51994
51995   {
51996     try {
51997       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
51998     } catch (std::out_of_range& e) {
51999       {
52000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52001       };
52002     } catch (std::exception& e) {
52003       {
52004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52005       };
52006     } catch (Dali::DaliException e) {
52007       {
52008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52009       };
52010     } catch (...) {
52011       {
52012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52013       };
52014     }
52015   }
52016
52017   jresult = (void *)result;
52018   return jresult;
52019 }
52020
52021
52022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
52023   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52024
52025   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52026   {
52027     try {
52028       delete arg1;
52029     } catch (std::out_of_range& e) {
52030       {
52031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52032       };
52033     } catch (std::exception& e) {
52034       {
52035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52036       };
52037     } catch (Dali::DaliException e) {
52038       {
52039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52040       };
52041     } catch (...) {
52042       {
52043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52044       };
52045     }
52046   }
52047
52048 }
52049
52050
52051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
52052   unsigned int jresult ;
52053   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52054   bool result;
52055
52056   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52057   {
52058     try {
52059       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);
52060     } catch (std::out_of_range& e) {
52061       {
52062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52063       };
52064     } catch (std::exception& e) {
52065       {
52066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52067       };
52068     } catch (Dali::DaliException e) {
52069       {
52070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52071       };
52072     } catch (...) {
52073       {
52074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52075       };
52076     }
52077   }
52078
52079   jresult = result;
52080   return jresult;
52081 }
52082
52083
52084 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
52085   unsigned long jresult ;
52086   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52087   std::size_t result;
52088
52089   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52090   {
52091     try {
52092       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);
52093     } catch (std::out_of_range& e) {
52094       {
52095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52096       };
52097     } catch (std::exception& e) {
52098       {
52099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52100       };
52101     } catch (Dali::DaliException e) {
52102       {
52103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52104       };
52105     } catch (...) {
52106       {
52107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52108       };
52109     }
52110   }
52111
52112   jresult = (unsigned long)result;
52113   return jresult;
52114 }
52115
52116
52117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
52118   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52119   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52120
52121   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52122   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52123   {
52124     try {
52125       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52126     } catch (std::out_of_range& e) {
52127       {
52128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52129       };
52130     } catch (std::exception& e) {
52131       {
52132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52133       };
52134     } catch (Dali::DaliException e) {
52135       {
52136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52137       };
52138     } catch (...) {
52139       {
52140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52141       };
52142     }
52143   }
52144
52145 }
52146
52147
52148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
52149   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52150   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52151
52152   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52153   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52154   {
52155     try {
52156       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52157     } catch (std::out_of_range& e) {
52158       {
52159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52160       };
52161     } catch (std::exception& e) {
52162       {
52163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52164       };
52165     } catch (Dali::DaliException e) {
52166       {
52167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52168       };
52169     } catch (...) {
52170       {
52171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52172       };
52173     }
52174   }
52175
52176 }
52177
52178
52179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52180   unsigned int jresult ;
52181   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52182   Dali::Actor arg2 ;
52183   Dali::WheelEvent *arg3 = 0 ;
52184   Dali::Actor *argp2 ;
52185   bool result;
52186
52187   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52188   argp2 = (Dali::Actor *)jarg2;
52189   if (!argp2) {
52190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52191     return 0;
52192   }
52193   arg2 = *argp2;
52194   arg3 = (Dali::WheelEvent *)jarg3;
52195   if (!arg3) {
52196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
52197     return 0;
52198   }
52199   {
52200     try {
52201       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
52202     } catch (std::out_of_range& e) {
52203       {
52204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52205       };
52206     } catch (std::exception& e) {
52207       {
52208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52209       };
52210     } catch (Dali::DaliException e) {
52211       {
52212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52213       };
52214     } catch (...) {
52215       {
52216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52217       };
52218     }
52219   }
52220
52221   jresult = result;
52222   return jresult;
52223 }
52224
52225
52226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
52227   void * jresult ;
52228   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
52229
52230   {
52231     try {
52232       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
52233     } catch (std::out_of_range& e) {
52234       {
52235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52236       };
52237     } catch (std::exception& e) {
52238       {
52239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52240       };
52241     } catch (Dali::DaliException e) {
52242       {
52243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52244       };
52245     } catch (...) {
52246       {
52247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52248       };
52249     }
52250   }
52251
52252   jresult = (void *)result;
52253   return jresult;
52254 }
52255
52256
52257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
52258   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52259
52260   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52261   {
52262     try {
52263       delete arg1;
52264     } catch (std::out_of_range& e) {
52265       {
52266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52267       };
52268     } catch (std::exception& e) {
52269       {
52270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52271       };
52272     } catch (Dali::DaliException e) {
52273       {
52274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52275       };
52276     } catch (...) {
52277       {
52278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52279       };
52280     }
52281   }
52282
52283 }
52284
52285
52286 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
52287   unsigned int jresult ;
52288   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52289   bool result;
52290
52291   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52292   {
52293     try {
52294       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
52295     } catch (std::out_of_range& e) {
52296       {
52297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52298       };
52299     } catch (std::exception& e) {
52300       {
52301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52302       };
52303     } catch (Dali::DaliException e) {
52304       {
52305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52306       };
52307     } catch (...) {
52308       {
52309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52310       };
52311     }
52312   }
52313
52314   jresult = result;
52315   return jresult;
52316 }
52317
52318
52319 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
52320   unsigned long jresult ;
52321   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52322   std::size_t result;
52323
52324   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52325   {
52326     try {
52327       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
52328     } catch (std::out_of_range& e) {
52329       {
52330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52331       };
52332     } catch (std::exception& e) {
52333       {
52334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52335       };
52336     } catch (Dali::DaliException e) {
52337       {
52338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52339       };
52340     } catch (...) {
52341       {
52342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52343       };
52344     }
52345   }
52346
52347   jresult = (unsigned long)result;
52348   return jresult;
52349 }
52350
52351
52352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
52353   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52354   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52355
52356   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52357   arg2 = (void (*)(Dali::Actor))jarg2;
52358   {
52359     try {
52360       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
52361     } catch (std::out_of_range& e) {
52362       {
52363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52364       };
52365     } catch (std::exception& e) {
52366       {
52367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52368       };
52369     } catch (Dali::DaliException e) {
52370       {
52371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52372       };
52373     } catch (...) {
52374       {
52375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52376       };
52377     }
52378   }
52379
52380 }
52381
52382
52383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
52384   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52385   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52386
52387   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52388   arg2 = (void (*)(Dali::Actor))jarg2;
52389   {
52390     try {
52391       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
52392     } catch (std::out_of_range& e) {
52393       {
52394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52395       };
52396     } catch (std::exception& e) {
52397       {
52398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52399       };
52400     } catch (Dali::DaliException e) {
52401       {
52402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52403       };
52404     } catch (...) {
52405       {
52406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52407       };
52408     }
52409   }
52410
52411 }
52412
52413
52414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
52415   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52416   Dali::Actor arg2 ;
52417   Dali::Actor *argp2 ;
52418
52419   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52420   argp2 = (Dali::Actor *)jarg2;
52421   if (!argp2) {
52422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52423     return ;
52424   }
52425   arg2 = *argp2;
52426   {
52427     try {
52428       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
52429     } catch (std::out_of_range& e) {
52430       {
52431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52432       };
52433     } catch (std::exception& e) {
52434       {
52435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52436       };
52437     } catch (Dali::DaliException e) {
52438       {
52439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52440       };
52441     } catch (...) {
52442       {
52443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52444       };
52445     }
52446   }
52447
52448 }
52449
52450
52451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
52452   void * jresult ;
52453   Dali::Signal< void (Dali::Actor) > *result = 0 ;
52454
52455   {
52456     try {
52457       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
52458     } catch (std::out_of_range& e) {
52459       {
52460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52461       };
52462     } catch (std::exception& e) {
52463       {
52464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52465       };
52466     } catch (Dali::DaliException e) {
52467       {
52468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52469       };
52470     } catch (...) {
52471       {
52472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52473       };
52474     }
52475   }
52476
52477   jresult = (void *)result;
52478   return jresult;
52479 }
52480
52481
52482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
52483   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52484
52485   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52486   {
52487     try {
52488       delete arg1;
52489     } catch (std::out_of_range& e) {
52490       {
52491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52492       };
52493     } catch (std::exception& e) {
52494       {
52495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52496       };
52497     } catch (Dali::DaliException e) {
52498       {
52499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52500       };
52501     } catch (...) {
52502       {
52503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52504       };
52505     }
52506   }
52507
52508 }
52509
52510
52511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
52512   unsigned int jresult ;
52513   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52514   bool result;
52515
52516   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52517   {
52518     try {
52519       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52520     } catch (std::out_of_range& e) {
52521       {
52522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52523       };
52524     } catch (std::exception& e) {
52525       {
52526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52527       };
52528     } catch (Dali::DaliException e) {
52529       {
52530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52531       };
52532     } catch (...) {
52533       {
52534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52535       };
52536     }
52537   }
52538
52539   jresult = result;
52540   return jresult;
52541 }
52542
52543
52544 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
52545   unsigned long jresult ;
52546   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52547   std::size_t result;
52548
52549   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52550   {
52551     try {
52552       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52553     } catch (std::out_of_range& e) {
52554       {
52555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52556       };
52557     } catch (std::exception& e) {
52558       {
52559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52560       };
52561     } catch (Dali::DaliException e) {
52562       {
52563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52564       };
52565     } catch (...) {
52566       {
52567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52568       };
52569     }
52570   }
52571
52572   jresult = (unsigned long)result;
52573   return jresult;
52574 }
52575
52576
52577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
52578   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52579   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52580
52581   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52582   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52583   {
52584     try {
52585       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52586     } catch (std::out_of_range& e) {
52587       {
52588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52589       };
52590     } catch (std::exception& e) {
52591       {
52592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52593       };
52594     } catch (Dali::DaliException e) {
52595       {
52596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52597       };
52598     } catch (...) {
52599       {
52600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52601       };
52602     }
52603   }
52604
52605 }
52606
52607
52608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
52609   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52610   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52611
52612   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52613   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52614   {
52615     try {
52616       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52617     } catch (std::out_of_range& e) {
52618       {
52619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52620       };
52621     } catch (std::exception& e) {
52622       {
52623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52624       };
52625     } catch (Dali::DaliException e) {
52626       {
52627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52628       };
52629     } catch (...) {
52630       {
52631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52632       };
52633     }
52634   }
52635
52636 }
52637
52638
52639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
52640   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52641   Dali::KeyEvent *arg2 = 0 ;
52642
52643   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52644   arg2 = (Dali::KeyEvent *)jarg2;
52645   if (!arg2) {
52646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
52647     return ;
52648   }
52649   {
52650     try {
52651       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
52652     } catch (std::out_of_range& e) {
52653       {
52654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52655       };
52656     } catch (std::exception& e) {
52657       {
52658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52659       };
52660     } catch (Dali::DaliException e) {
52661       {
52662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52663       };
52664     } catch (...) {
52665       {
52666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52667       };
52668     }
52669   }
52670
52671 }
52672
52673
52674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
52675   void * jresult ;
52676   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
52677
52678   {
52679     try {
52680       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
52681     } catch (std::out_of_range& e) {
52682       {
52683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52684       };
52685     } catch (std::exception& e) {
52686       {
52687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52688       };
52689     } catch (Dali::DaliException e) {
52690       {
52691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52692       };
52693     } catch (...) {
52694       {
52695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52696       };
52697     }
52698   }
52699
52700   jresult = (void *)result;
52701   return jresult;
52702 }
52703
52704
52705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
52706   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52707
52708   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52709   {
52710     try {
52711       delete arg1;
52712     } catch (std::out_of_range& e) {
52713       {
52714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52715       };
52716     } catch (std::exception& e) {
52717       {
52718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52719       };
52720     } catch (Dali::DaliException e) {
52721       {
52722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52723       };
52724     } catch (...) {
52725       {
52726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52727       };
52728     }
52729   }
52730
52731 }
52732
52733
52734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
52735   unsigned int jresult ;
52736   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52737   bool result;
52738
52739   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52740   {
52741     try {
52742       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
52743     } catch (std::out_of_range& e) {
52744       {
52745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52746       };
52747     } catch (std::exception& e) {
52748       {
52749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52750       };
52751     } catch (Dali::DaliException e) {
52752       {
52753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52754       };
52755     } catch (...) {
52756       {
52757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52758       };
52759     }
52760   }
52761
52762   jresult = result;
52763   return jresult;
52764 }
52765
52766
52767 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
52768   unsigned long jresult ;
52769   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52770   std::size_t result;
52771
52772   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52773   {
52774     try {
52775       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
52776     } catch (std::out_of_range& e) {
52777       {
52778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52779       };
52780     } catch (std::exception& e) {
52781       {
52782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52783       };
52784     } catch (Dali::DaliException e) {
52785       {
52786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52787       };
52788     } catch (...) {
52789       {
52790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52791       };
52792     }
52793   }
52794
52795   jresult = (unsigned long)result;
52796   return jresult;
52797 }
52798
52799
52800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
52801   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52802   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
52803
52804   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52805   arg2 = (void (*)(Dali::TouchData const &))jarg2;
52806   {
52807     try {
52808       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52809     } catch (std::out_of_range& e) {
52810       {
52811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52812       };
52813     } catch (std::exception& e) {
52814       {
52815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52816       };
52817     } catch (Dali::DaliException e) {
52818       {
52819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52820       };
52821     } catch (...) {
52822       {
52823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52824       };
52825     }
52826   }
52827
52828 }
52829
52830
52831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
52832   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52833   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
52834
52835   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52836   arg2 = (void (*)(Dali::TouchData const &))jarg2;
52837   {
52838     try {
52839       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52840     } catch (std::out_of_range& e) {
52841       {
52842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52843       };
52844     } catch (std::exception& e) {
52845       {
52846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52847       };
52848     } catch (Dali::DaliException e) {
52849       {
52850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52851       };
52852     } catch (...) {
52853       {
52854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52855       };
52856     }
52857   }
52858
52859 }
52860
52861
52862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
52863   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52864   Dali::TouchData *arg2 = 0 ;
52865
52866   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52867   arg2 = (Dali::TouchData *)jarg2;
52868   if (!arg2) {
52869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
52870     return ;
52871   }
52872   {
52873     try {
52874       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
52875     } catch (std::out_of_range& e) {
52876       {
52877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52878       };
52879     } catch (std::exception& e) {
52880       {
52881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52882       };
52883     } catch (Dali::DaliException e) {
52884       {
52885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52886       };
52887     } catch (...) {
52888       {
52889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52890       };
52891     }
52892   }
52893
52894 }
52895
52896
52897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
52898   void * jresult ;
52899   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
52900
52901   {
52902     try {
52903       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
52904     } catch (std::out_of_range& e) {
52905       {
52906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52907       };
52908     } catch (std::exception& e) {
52909       {
52910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52911       };
52912     } catch (Dali::DaliException e) {
52913       {
52914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52915       };
52916     } catch (...) {
52917       {
52918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52919       };
52920     }
52921   }
52922
52923   jresult = (void *)result;
52924   return jresult;
52925 }
52926
52927
52928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
52929   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52930
52931   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52932   {
52933     try {
52934       delete arg1;
52935     } catch (std::out_of_range& e) {
52936       {
52937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52938       };
52939     } catch (std::exception& e) {
52940       {
52941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52942       };
52943     } catch (Dali::DaliException e) {
52944       {
52945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52946       };
52947     } catch (...) {
52948       {
52949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52950       };
52951     }
52952   }
52953
52954 }
52955
52956
52957 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
52958   unsigned int jresult ;
52959   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
52960   bool result;
52961
52962   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
52963   {
52964     try {
52965       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
52966     } catch (std::out_of_range& e) {
52967       {
52968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52969       };
52970     } catch (std::exception& e) {
52971       {
52972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52973       };
52974     } catch (Dali::DaliException e) {
52975       {
52976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52977       };
52978     } catch (...) {
52979       {
52980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52981       };
52982     }
52983   }
52984
52985   jresult = result;
52986   return jresult;
52987 }
52988
52989
52990 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
52991   unsigned long jresult ;
52992   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
52993   std::size_t result;
52994
52995   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
52996   {
52997     try {
52998       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
52999     } catch (std::out_of_range& e) {
53000       {
53001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53002       };
53003     } catch (std::exception& e) {
53004       {
53005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53006       };
53007     } catch (Dali::DaliException e) {
53008       {
53009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53010       };
53011     } catch (...) {
53012       {
53013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53014       };
53015     }
53016   }
53017
53018   jresult = (unsigned long)result;
53019   return jresult;
53020 }
53021
53022
53023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
53024   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53025   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53026
53027   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53028   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53029   {
53030     try {
53031       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53032     } catch (std::out_of_range& e) {
53033       {
53034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53035       };
53036     } catch (std::exception& e) {
53037       {
53038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53039       };
53040     } catch (Dali::DaliException e) {
53041       {
53042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53043       };
53044     } catch (...) {
53045       {
53046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53047       };
53048     }
53049   }
53050
53051 }
53052
53053
53054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
53055   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53056   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53057
53058   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53059   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53060   {
53061     try {
53062       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53063     } catch (std::out_of_range& e) {
53064       {
53065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53066       };
53067     } catch (std::exception& e) {
53068       {
53069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53070       };
53071     } catch (Dali::DaliException e) {
53072       {
53073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53074       };
53075     } catch (...) {
53076       {
53077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53078       };
53079     }
53080   }
53081
53082 }
53083
53084
53085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
53086   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53087   Dali::WheelEvent *arg2 = 0 ;
53088
53089   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53090   arg2 = (Dali::WheelEvent *)jarg2;
53091   if (!arg2) {
53092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
53093     return ;
53094   }
53095   {
53096     try {
53097       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
53098     } catch (std::out_of_range& e) {
53099       {
53100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53101       };
53102     } catch (std::exception& e) {
53103       {
53104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53105       };
53106     } catch (Dali::DaliException e) {
53107       {
53108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53109       };
53110     } catch (...) {
53111       {
53112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53113       };
53114     }
53115   }
53116
53117 }
53118
53119
53120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
53121   void * jresult ;
53122   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
53123
53124   {
53125     try {
53126       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
53127     } catch (std::out_of_range& e) {
53128       {
53129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53130       };
53131     } catch (std::exception& e) {
53132       {
53133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53134       };
53135     } catch (Dali::DaliException e) {
53136       {
53137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53138       };
53139     } catch (...) {
53140       {
53141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53142       };
53143     }
53144   }
53145
53146   jresult = (void *)result;
53147   return jresult;
53148 }
53149
53150
53151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
53152   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53153
53154   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53155   {
53156     try {
53157       delete arg1;
53158     } catch (std::out_of_range& e) {
53159       {
53160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53161       };
53162     } catch (std::exception& e) {
53163       {
53164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53165       };
53166     } catch (Dali::DaliException e) {
53167       {
53168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53169       };
53170     } catch (...) {
53171       {
53172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53173       };
53174     }
53175   }
53176
53177 }
53178
53179
53180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
53181   void * jresult ;
53182   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53183
53184   {
53185     try {
53186       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
53187     } catch (std::out_of_range& e) {
53188       {
53189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53190       };
53191     } catch (std::exception& e) {
53192       {
53193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53194       };
53195     } catch (Dali::DaliException e) {
53196       {
53197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53198       };
53199     } catch (...) {
53200       {
53201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53202       };
53203     }
53204   }
53205
53206   jresult = (void *)result;
53207   return jresult;
53208 }
53209
53210
53211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
53212   void * jresult ;
53213   Dali::Radian arg1 ;
53214   Dali::Radian arg2 ;
53215   Dali::Radian *argp1 ;
53216   Dali::Radian *argp2 ;
53217   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53218
53219   argp1 = (Dali::Radian *)jarg1;
53220   if (!argp1) {
53221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53222     return 0;
53223   }
53224   arg1 = *argp1;
53225   argp2 = (Dali::Radian *)jarg2;
53226   if (!argp2) {
53227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53228     return 0;
53229   }
53230   arg2 = *argp2;
53231   {
53232     try {
53233       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
53234     } catch (std::out_of_range& e) {
53235       {
53236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53237       };
53238     } catch (std::exception& e) {
53239       {
53240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53241       };
53242     } catch (Dali::DaliException e) {
53243       {
53244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53245       };
53246     } catch (...) {
53247       {
53248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53249       };
53250     }
53251   }
53252
53253   jresult = (void *)result;
53254   return jresult;
53255 }
53256
53257
53258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
53259   void * jresult ;
53260   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
53261   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53262
53263   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53264   if (!arg1) {
53265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
53266     return 0;
53267   }
53268   {
53269     try {
53270       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
53271     } catch (std::out_of_range& e) {
53272       {
53273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53274       };
53275     } catch (std::exception& e) {
53276       {
53277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53278       };
53279     } catch (Dali::DaliException e) {
53280       {
53281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53282       };
53283     } catch (...) {
53284       {
53285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53286       };
53287     }
53288   }
53289
53290   jresult = (void *)result;
53291   return jresult;
53292 }
53293
53294
53295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
53296   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53297   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53298
53299   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53300   arg2 = (Dali::Radian *)jarg2;
53301   if (arg1) (arg1)->first = *arg2;
53302 }
53303
53304
53305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
53306   void * jresult ;
53307   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53308   Dali::Radian *result = 0 ;
53309
53310   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53311   result = (Dali::Radian *)& ((arg1)->first);
53312   jresult = (void *)result;
53313   return jresult;
53314 }
53315
53316
53317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
53318   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53319   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53320
53321   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53322   arg2 = (Dali::Radian *)jarg2;
53323   if (arg1) (arg1)->second = *arg2;
53324 }
53325
53326
53327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
53328   void * jresult ;
53329   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53330   Dali::Radian *result = 0 ;
53331
53332   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53333   result = (Dali::Radian *)& ((arg1)->second);
53334   jresult = (void *)result;
53335   return jresult;
53336 }
53337
53338
53339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
53340   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53341
53342   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53343   {
53344     try {
53345       delete arg1;
53346     } catch (std::out_of_range& e) {
53347       {
53348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53349       };
53350     } catch (std::exception& e) {
53351       {
53352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53353       };
53354     } catch (Dali::DaliException e) {
53355       {
53356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53357       };
53358     } catch (...) {
53359       {
53360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53361       };
53362     }
53363   }
53364
53365 }
53366
53367
53368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
53369   unsigned int jresult ;
53370   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53371   bool result;
53372
53373   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53374   {
53375     try {
53376       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);
53377     } catch (std::out_of_range& e) {
53378       {
53379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53380       };
53381     } catch (std::exception& e) {
53382       {
53383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53384       };
53385     } catch (Dali::DaliException e) {
53386       {
53387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53388       };
53389     } catch (...) {
53390       {
53391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53392       };
53393     }
53394   }
53395
53396   jresult = result;
53397   return jresult;
53398 }
53399
53400
53401 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53402   unsigned long jresult ;
53403   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53404   std::size_t result;
53405
53406   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53407   {
53408     try {
53409       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);
53410     } catch (std::out_of_range& e) {
53411       {
53412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53413       };
53414     } catch (std::exception& e) {
53415       {
53416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53417       };
53418     } catch (Dali::DaliException e) {
53419       {
53420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53421       };
53422     } catch (...) {
53423       {
53424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53425       };
53426     }
53427   }
53428
53429   jresult = (unsigned long)result;
53430   return jresult;
53431 }
53432
53433
53434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53435   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53436   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53437
53438   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53439   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53440   {
53441     try {
53442       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53443     } catch (std::out_of_range& e) {
53444       {
53445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53446       };
53447     } catch (std::exception& e) {
53448       {
53449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53450       };
53451     } catch (Dali::DaliException e) {
53452       {
53453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53454       };
53455     } catch (...) {
53456       {
53457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53458       };
53459     }
53460   }
53461
53462 }
53463
53464
53465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53466   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53467   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53468
53469   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53470   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53471   {
53472     try {
53473       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53474     } catch (std::out_of_range& e) {
53475       {
53476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53477       };
53478     } catch (std::exception& e) {
53479       {
53480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53481       };
53482     } catch (Dali::DaliException e) {
53483       {
53484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53485       };
53486     } catch (...) {
53487       {
53488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53489       };
53490     }
53491   }
53492
53493 }
53494
53495
53496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53497   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53498   Dali::Actor arg2 ;
53499   Dali::PanGesture *arg3 = 0 ;
53500   Dali::Actor *argp2 ;
53501
53502   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53503   argp2 = (Dali::Actor *)jarg2;
53504   if (!argp2) {
53505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53506     return ;
53507   }
53508   arg2 = *argp2;
53509   arg3 = (Dali::PanGesture *)jarg3;
53510   if (!arg3) {
53511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
53512     return ;
53513   }
53514   {
53515     try {
53516       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
53517     } catch (std::out_of_range& e) {
53518       {
53519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53520       };
53521     } catch (std::exception& e) {
53522       {
53523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53524       };
53525     } catch (Dali::DaliException e) {
53526       {
53527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53528       };
53529     } catch (...) {
53530       {
53531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53532       };
53533     }
53534   }
53535
53536 }
53537
53538
53539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
53540   void * jresult ;
53541   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
53542
53543   {
53544     try {
53545       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
53546     } catch (std::out_of_range& e) {
53547       {
53548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53549       };
53550     } catch (std::exception& e) {
53551       {
53552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53553       };
53554     } catch (Dali::DaliException e) {
53555       {
53556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53557       };
53558     } catch (...) {
53559       {
53560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53561       };
53562     }
53563   }
53564
53565   jresult = (void *)result;
53566   return jresult;
53567 }
53568
53569
53570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
53571   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53572
53573   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53574   {
53575     try {
53576       delete arg1;
53577     } catch (std::out_of_range& e) {
53578       {
53579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53580       };
53581     } catch (std::exception& e) {
53582       {
53583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53584       };
53585     } catch (Dali::DaliException e) {
53586       {
53587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53588       };
53589     } catch (...) {
53590       {
53591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53592       };
53593     }
53594   }
53595
53596 }
53597
53598
53599 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
53600   unsigned int jresult ;
53601   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53602   bool result;
53603
53604   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53605   {
53606     try {
53607       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);
53608     } catch (std::out_of_range& e) {
53609       {
53610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53611       };
53612     } catch (std::exception& e) {
53613       {
53614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53615       };
53616     } catch (Dali::DaliException e) {
53617       {
53618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53619       };
53620     } catch (...) {
53621       {
53622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53623       };
53624     }
53625   }
53626
53627   jresult = result;
53628   return jresult;
53629 }
53630
53631
53632 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53633   unsigned long jresult ;
53634   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53635   std::size_t result;
53636
53637   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53638   {
53639     try {
53640       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);
53641     } catch (std::out_of_range& e) {
53642       {
53643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53644       };
53645     } catch (std::exception& e) {
53646       {
53647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53648       };
53649     } catch (Dali::DaliException e) {
53650       {
53651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53652       };
53653     } catch (...) {
53654       {
53655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53656       };
53657     }
53658   }
53659
53660   jresult = (unsigned long)result;
53661   return jresult;
53662 }
53663
53664
53665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53666   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53667   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
53668
53669   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53670   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
53671   {
53672     try {
53673       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53674     } catch (std::out_of_range& e) {
53675       {
53676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53677       };
53678     } catch (std::exception& e) {
53679       {
53680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53681       };
53682     } catch (Dali::DaliException e) {
53683       {
53684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53685       };
53686     } catch (...) {
53687       {
53688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53689       };
53690     }
53691   }
53692
53693 }
53694
53695
53696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53697   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53698   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
53699
53700   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53701   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
53702   {
53703     try {
53704       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53705     } catch (std::out_of_range& e) {
53706       {
53707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53708       };
53709     } catch (std::exception& e) {
53710       {
53711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53712       };
53713     } catch (Dali::DaliException e) {
53714       {
53715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53716       };
53717     } catch (...) {
53718       {
53719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53720       };
53721     }
53722   }
53723
53724 }
53725
53726
53727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53728   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53729   Dali::Actor arg2 ;
53730   Dali::PinchGesture *arg3 = 0 ;
53731   Dali::Actor *argp2 ;
53732
53733   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53734   argp2 = (Dali::Actor *)jarg2;
53735   if (!argp2) {
53736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53737     return ;
53738   }
53739   arg2 = *argp2;
53740   arg3 = (Dali::PinchGesture *)jarg3;
53741   if (!arg3) {
53742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
53743     return ;
53744   }
53745   {
53746     try {
53747       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
53748     } catch (std::out_of_range& e) {
53749       {
53750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53751       };
53752     } catch (std::exception& e) {
53753       {
53754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53755       };
53756     } catch (Dali::DaliException e) {
53757       {
53758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53759       };
53760     } catch (...) {
53761       {
53762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53763       };
53764     }
53765   }
53766
53767 }
53768
53769
53770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
53771   void * jresult ;
53772   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
53773
53774   {
53775     try {
53776       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
53777     } catch (std::out_of_range& e) {
53778       {
53779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53780       };
53781     } catch (std::exception& e) {
53782       {
53783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53784       };
53785     } catch (Dali::DaliException e) {
53786       {
53787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53788       };
53789     } catch (...) {
53790       {
53791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53792       };
53793     }
53794   }
53795
53796   jresult = (void *)result;
53797   return jresult;
53798 }
53799
53800
53801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
53802   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53803
53804   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53805   {
53806     try {
53807       delete arg1;
53808     } catch (std::out_of_range& e) {
53809       {
53810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53811       };
53812     } catch (std::exception& e) {
53813       {
53814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53815       };
53816     } catch (Dali::DaliException e) {
53817       {
53818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53819       };
53820     } catch (...) {
53821       {
53822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53823       };
53824     }
53825   }
53826
53827 }
53828
53829
53830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
53831   unsigned int jresult ;
53832   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53833   bool result;
53834
53835   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53836   {
53837     try {
53838       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);
53839     } catch (std::out_of_range& e) {
53840       {
53841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53842       };
53843     } catch (std::exception& e) {
53844       {
53845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53846       };
53847     } catch (Dali::DaliException e) {
53848       {
53849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53850       };
53851     } catch (...) {
53852       {
53853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53854       };
53855     }
53856   }
53857
53858   jresult = result;
53859   return jresult;
53860 }
53861
53862
53863 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53864   unsigned long jresult ;
53865   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53866   std::size_t result;
53867
53868   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53869   {
53870     try {
53871       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);
53872     } catch (std::out_of_range& e) {
53873       {
53874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53875       };
53876     } catch (std::exception& e) {
53877       {
53878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53879       };
53880     } catch (Dali::DaliException e) {
53881       {
53882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53883       };
53884     } catch (...) {
53885       {
53886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53887       };
53888     }
53889   }
53890
53891   jresult = (unsigned long)result;
53892   return jresult;
53893 }
53894
53895
53896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53897   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53898   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
53899
53900   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53901   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
53902   {
53903     try {
53904       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53905     } catch (std::out_of_range& e) {
53906       {
53907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53908       };
53909     } catch (std::exception& e) {
53910       {
53911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53912       };
53913     } catch (Dali::DaliException e) {
53914       {
53915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53916       };
53917     } catch (...) {
53918       {
53919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53920       };
53921     }
53922   }
53923
53924 }
53925
53926
53927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53928   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53929   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
53930
53931   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53932   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
53933   {
53934     try {
53935       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53936     } catch (std::out_of_range& e) {
53937       {
53938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53939       };
53940     } catch (std::exception& e) {
53941       {
53942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53943       };
53944     } catch (Dali::DaliException e) {
53945       {
53946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53947       };
53948     } catch (...) {
53949       {
53950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53951       };
53952     }
53953   }
53954
53955 }
53956
53957
53958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53959   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53960   Dali::Actor arg2 ;
53961   Dali::TapGesture *arg3 = 0 ;
53962   Dali::Actor *argp2 ;
53963
53964   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53965   argp2 = (Dali::Actor *)jarg2;
53966   if (!argp2) {
53967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53968     return ;
53969   }
53970   arg2 = *argp2;
53971   arg3 = (Dali::TapGesture *)jarg3;
53972   if (!arg3) {
53973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
53974     return ;
53975   }
53976   {
53977     try {
53978       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
53979     } catch (std::out_of_range& e) {
53980       {
53981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53982       };
53983     } catch (std::exception& e) {
53984       {
53985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53986       };
53987     } catch (Dali::DaliException e) {
53988       {
53989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53990       };
53991     } catch (...) {
53992       {
53993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53994       };
53995     }
53996   }
53997
53998 }
53999
54000
54001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
54002   void * jresult ;
54003   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
54004
54005   {
54006     try {
54007       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
54008     } catch (std::out_of_range& e) {
54009       {
54010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54011       };
54012     } catch (std::exception& e) {
54013       {
54014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54015       };
54016     } catch (Dali::DaliException e) {
54017       {
54018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54019       };
54020     } catch (...) {
54021       {
54022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54023       };
54024     }
54025   }
54026
54027   jresult = (void *)result;
54028   return jresult;
54029 }
54030
54031
54032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
54033   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54034
54035   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54036   {
54037     try {
54038       delete arg1;
54039     } catch (std::out_of_range& e) {
54040       {
54041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54042       };
54043     } catch (std::exception& e) {
54044       {
54045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54046       };
54047     } catch (Dali::DaliException e) {
54048       {
54049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54050       };
54051     } catch (...) {
54052       {
54053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54054       };
54055     }
54056   }
54057
54058 }
54059
54060 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
54061   unsigned int jresult ;
54062   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54063   bool result = false;
54064
54065   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54066   {
54067     try {
54068       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);
54069     } catch (std::out_of_range& e) {
54070       {
54071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54072       };
54073     } catch (std::exception& e) {
54074       {
54075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54076       };
54077     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54078   }
54079   jresult = result;
54080   return jresult;
54081 }
54082
54083 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
54084   unsigned long jresult ;
54085   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54086   std::size_t result = 0;
54087
54088   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54089   {
54090     try {
54091       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);
54092     } catch (std::out_of_range& e) {
54093       {
54094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54095       };
54096     } catch (std::exception& e) {
54097       {
54098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54099       };
54100     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54101   }
54102   jresult = (unsigned long)result;
54103   return jresult;
54104 }
54105
54106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
54107   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54108   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54109
54110   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54111   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54112   {
54113     try {
54114       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
54115     } catch (std::out_of_range& e) {
54116       {
54117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54118       };
54119     } catch (std::exception& e) {
54120       {
54121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54122       };
54123     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54124   }
54125 }
54126
54127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
54128   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54129   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54130
54131   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54132   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54133   {
54134     try {
54135       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
54136     } catch (std::out_of_range& e) {
54137       {
54138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54139       };
54140     } catch (std::exception& e) {
54141       {
54142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54143       };
54144     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54145   }
54146 }
54147
54148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
54149   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54150   Dali::Actor arg2 ;
54151   //bool arg3 ;
54152   Dali::LayoutDirection::Type arg4 ;
54153   Dali::Actor *argp2 ;
54154
54155   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54156   argp2 = (Dali::Actor *)jarg2;
54157   if (!argp2) {
54158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54159     return ;
54160   }
54161   arg2 = *argp2;
54162   //arg3 = jarg3 ? true : false;
54163   arg4 = (Dali::LayoutDirection::Type)jarg4;
54164   {
54165     try {
54166       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
54167     } catch (std::out_of_range& e) {
54168       {
54169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54170       };
54171     } catch (std::exception& e) {
54172       {
54173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54174       };
54175     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54176   }
54177 }
54178
54179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
54180   void * jresult ;
54181   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
54182
54183   {
54184     try {
54185       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
54186     } catch (std::out_of_range& e) {
54187       {
54188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54189       };
54190     } catch (std::exception& e) {
54191       {
54192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54193       };
54194     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54195   }
54196   jresult = (void *)result;
54197   return jresult;
54198 }
54199
54200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
54201   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54202
54203   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54204   {
54205     try {
54206       delete arg1;
54207     } catch (std::out_of_range& e) {
54208       {
54209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54210       };
54211     } catch (std::exception& e) {
54212       {
54213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54214       };
54215     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54216   }
54217 }
54218
54219 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
54220   unsigned int jresult ;
54221   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54222   bool result;
54223
54224   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54225   {
54226     try {
54227       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);
54228     } catch (std::out_of_range& e) {
54229       {
54230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54231       };
54232     } catch (std::exception& e) {
54233       {
54234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54235       };
54236     } catch (Dali::DaliException e) {
54237       {
54238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54239       };
54240     } catch (...) {
54241       {
54242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54243       };
54244     }
54245   }
54246
54247   jresult = result;
54248   return jresult;
54249 }
54250
54251
54252 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
54253   unsigned long jresult ;
54254   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54255   std::size_t result;
54256
54257   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54258   {
54259     try {
54260       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);
54261     } catch (std::out_of_range& e) {
54262       {
54263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54264       };
54265     } catch (std::exception& e) {
54266       {
54267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54268       };
54269     } catch (Dali::DaliException e) {
54270       {
54271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54272       };
54273     } catch (...) {
54274       {
54275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54276       };
54277     }
54278   }
54279
54280   jresult = (unsigned long)result;
54281   return jresult;
54282 }
54283
54284
54285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
54286   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54287   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54288
54289   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54290   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54291   {
54292     try {
54293       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
54294     } catch (std::out_of_range& e) {
54295       {
54296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54297       };
54298     } catch (std::exception& e) {
54299       {
54300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54301       };
54302     } catch (Dali::DaliException e) {
54303       {
54304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54305       };
54306     } catch (...) {
54307       {
54308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54309       };
54310     }
54311   }
54312
54313 }
54314
54315
54316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54317   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54318   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54319
54320   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54321   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54322   {
54323     try {
54324       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
54325     } catch (std::out_of_range& e) {
54326       {
54327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54328       };
54329     } catch (std::exception& e) {
54330       {
54331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54332       };
54333     } catch (Dali::DaliException e) {
54334       {
54335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54336       };
54337     } catch (...) {
54338       {
54339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54340       };
54341     }
54342   }
54343
54344 }
54345
54346
54347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
54348   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54349   Dali::Actor arg2 ;
54350   bool arg3 ;
54351   Dali::DevelActor::VisibilityChange::Type arg4 ;
54352   Dali::Actor *argp2 ;
54353
54354   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54355   argp2 = (Dali::Actor *)jarg2;
54356   if (!argp2) {
54357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54358     return ;
54359   }
54360   arg2 = *argp2;
54361   arg3 = jarg3 ? true : false;
54362   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
54363   {
54364     try {
54365       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54366     } catch (std::out_of_range& e) {
54367       {
54368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54369       };
54370     } catch (std::exception& e) {
54371       {
54372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54373       };
54374     } catch (Dali::DaliException e) {
54375       {
54376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54377       };
54378     } catch (...) {
54379       {
54380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54381       };
54382     }
54383   }
54384
54385 }
54386
54387
54388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
54389   void * jresult ;
54390   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
54391
54392   {
54393     try {
54394       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
54395     } catch (std::out_of_range& e) {
54396       {
54397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54398       };
54399     } catch (std::exception& e) {
54400       {
54401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54402       };
54403     } catch (Dali::DaliException e) {
54404       {
54405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54406       };
54407     } catch (...) {
54408       {
54409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54410       };
54411     }
54412   }
54413
54414   jresult = (void *)result;
54415   return jresult;
54416 }
54417
54418
54419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
54420   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54421
54422   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54423   {
54424     try {
54425       delete arg1;
54426     } catch (std::out_of_range& e) {
54427       {
54428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54429       };
54430     } catch (std::exception& e) {
54431       {
54432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54433       };
54434     } catch (Dali::DaliException e) {
54435       {
54436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54437       };
54438     } catch (...) {
54439       {
54440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54441       };
54442     }
54443   }
54444
54445 }
54446
54447
54448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
54449   void * jresult ;
54450   Dali::Timer *result = 0 ;
54451
54452   {
54453     try {
54454       result = (Dali::Timer *)new Dali::Timer();
54455     } catch (std::out_of_range& e) {
54456       {
54457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54458       };
54459     } catch (std::exception& e) {
54460       {
54461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54462       };
54463     } catch (Dali::DaliException e) {
54464       {
54465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54466       };
54467     } catch (...) {
54468       {
54469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54470       };
54471     }
54472   }
54473
54474   jresult = (void *)result;
54475   return jresult;
54476 }
54477
54478
54479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
54480   void * jresult ;
54481   unsigned int arg1 ;
54482   Dali::Timer result;
54483
54484   arg1 = (unsigned int)jarg1;
54485   {
54486     try {
54487       result = Dali::Timer::New(arg1);
54488     } catch (std::out_of_range& e) {
54489       {
54490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54491       };
54492     } catch (std::exception& e) {
54493       {
54494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54495       };
54496     } catch (Dali::DaliException e) {
54497       {
54498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54499       };
54500     } catch (...) {
54501       {
54502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54503       };
54504     }
54505   }
54506
54507   jresult = new Dali::Timer((const Dali::Timer &)result);
54508   return jresult;
54509 }
54510
54511
54512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
54513   void * jresult ;
54514   Dali::Timer *arg1 = 0 ;
54515   Dali::Timer *result = 0 ;
54516
54517   arg1 = (Dali::Timer *)jarg1;
54518   if (!arg1) {
54519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
54520     return 0;
54521   }
54522   {
54523     try {
54524       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
54525     } catch (std::out_of_range& e) {
54526       {
54527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54528       };
54529     } catch (std::exception& e) {
54530       {
54531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54532       };
54533     } catch (Dali::DaliException e) {
54534       {
54535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54536       };
54537     } catch (...) {
54538       {
54539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54540       };
54541     }
54542   }
54543
54544   jresult = (void *)result;
54545   return jresult;
54546 }
54547
54548
54549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
54550   void * jresult ;
54551   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54552   Dali::Timer *arg2 = 0 ;
54553   Dali::Timer *result = 0 ;
54554
54555   arg1 = (Dali::Timer *)jarg1;
54556   arg2 = (Dali::Timer *)jarg2;
54557   if (!arg2) {
54558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
54559     return 0;
54560   }
54561   {
54562     try {
54563       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
54564     } catch (std::out_of_range& e) {
54565       {
54566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54567       };
54568     } catch (std::exception& e) {
54569       {
54570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54571       };
54572     } catch (Dali::DaliException e) {
54573       {
54574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54575       };
54576     } catch (...) {
54577       {
54578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54579       };
54580     }
54581   }
54582
54583   jresult = (void *)result;
54584   return jresult;
54585 }
54586
54587
54588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
54589   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54590
54591   arg1 = (Dali::Timer *)jarg1;
54592   {
54593     try {
54594       delete arg1;
54595     } catch (std::out_of_range& e) {
54596       {
54597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54598       };
54599     } catch (std::exception& e) {
54600       {
54601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54602       };
54603     } catch (Dali::DaliException e) {
54604       {
54605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54606       };
54607     } catch (...) {
54608       {
54609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54610       };
54611     }
54612   }
54613
54614 }
54615
54616
54617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
54618   void * jresult ;
54619   Dali::BaseHandle arg1 ;
54620   Dali::BaseHandle *argp1 ;
54621   Dali::Timer result;
54622
54623   argp1 = (Dali::BaseHandle *)jarg1;
54624   if (!argp1) {
54625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54626     return 0;
54627   }
54628   arg1 = *argp1;
54629   {
54630     try {
54631       result = Dali::Timer::DownCast(arg1);
54632     } catch (std::out_of_range& e) {
54633       {
54634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54635       };
54636     } catch (std::exception& e) {
54637       {
54638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54639       };
54640     } catch (Dali::DaliException e) {
54641       {
54642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54643       };
54644     } catch (...) {
54645       {
54646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54647       };
54648     }
54649   }
54650
54651   jresult = new Dali::Timer((const Dali::Timer &)result);
54652   return jresult;
54653 }
54654
54655
54656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
54657   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54658
54659   arg1 = (Dali::Timer *)jarg1;
54660   {
54661     try {
54662       (arg1)->Start();
54663     } catch (std::out_of_range& e) {
54664       {
54665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54666       };
54667     } catch (std::exception& e) {
54668       {
54669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54670       };
54671     } catch (Dali::DaliException e) {
54672       {
54673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54674       };
54675     } catch (...) {
54676       {
54677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54678       };
54679     }
54680   }
54681
54682 }
54683
54684
54685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
54686   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54687
54688   arg1 = (Dali::Timer *)jarg1;
54689   {
54690     try {
54691       (arg1)->Stop();
54692     } catch (std::out_of_range& e) {
54693       {
54694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54695       };
54696     } catch (std::exception& e) {
54697       {
54698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54699       };
54700     } catch (Dali::DaliException e) {
54701       {
54702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54703       };
54704     } catch (...) {
54705       {
54706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54707       };
54708     }
54709   }
54710
54711 }
54712
54713
54714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
54715   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54716   unsigned int arg2 ;
54717
54718   arg1 = (Dali::Timer *)jarg1;
54719   arg2 = (unsigned int)jarg2;
54720   {
54721     try {
54722       (arg1)->SetInterval(arg2);
54723     } catch (std::out_of_range& e) {
54724       {
54725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54726       };
54727     } catch (std::exception& e) {
54728       {
54729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54730       };
54731     } catch (Dali::DaliException e) {
54732       {
54733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54734       };
54735     } catch (...) {
54736       {
54737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54738       };
54739     }
54740   }
54741
54742 }
54743
54744
54745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
54746   unsigned int jresult ;
54747   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54748   unsigned int result;
54749
54750   arg1 = (Dali::Timer *)jarg1;
54751   {
54752     try {
54753       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
54754     } catch (std::out_of_range& e) {
54755       {
54756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54757       };
54758     } catch (std::exception& e) {
54759       {
54760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54761       };
54762     } catch (Dali::DaliException e) {
54763       {
54764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54765       };
54766     } catch (...) {
54767       {
54768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54769       };
54770     }
54771   }
54772
54773   jresult = result;
54774   return jresult;
54775 }
54776
54777
54778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
54779   unsigned int jresult ;
54780   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54781   bool result;
54782
54783   arg1 = (Dali::Timer *)jarg1;
54784   {
54785     try {
54786       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
54787     } catch (std::out_of_range& e) {
54788       {
54789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54790       };
54791     } catch (std::exception& e) {
54792       {
54793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54794       };
54795     } catch (Dali::DaliException e) {
54796       {
54797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54798       };
54799     } catch (...) {
54800       {
54801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54802       };
54803     }
54804   }
54805
54806   jresult = result;
54807   return jresult;
54808 }
54809
54810
54811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
54812   void * jresult ;
54813   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54814   Dali::Timer::TimerSignalType *result = 0 ;
54815
54816   arg1 = (Dali::Timer *)jarg1;
54817   {
54818     try {
54819       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
54820     } catch (std::out_of_range& e) {
54821       {
54822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54823       };
54824     } catch (std::exception& e) {
54825       {
54826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54827       };
54828     } catch (Dali::DaliException e) {
54829       {
54830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54831       };
54832     } catch (...) {
54833       {
54834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54835       };
54836     }
54837   }
54838
54839   jresult = (void *)result;
54840   return jresult;
54841 }
54842
54843
54844 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
54845   unsigned int jresult ;
54846   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
54847   bool result;
54848
54849   arg1 = (Dali::Signal< bool () > *)jarg1;
54850   {
54851     try {
54852       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
54853     } catch (std::out_of_range& e) {
54854       {
54855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54856       };
54857     } catch (std::exception& e) {
54858       {
54859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54860       };
54861     } catch (Dali::DaliException e) {
54862       {
54863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54864       };
54865     } catch (...) {
54866       {
54867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54868       };
54869     }
54870   }
54871
54872   jresult = result;
54873   return jresult;
54874 }
54875
54876
54877 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
54878   unsigned long jresult ;
54879   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
54880   std::size_t result;
54881
54882   arg1 = (Dali::Signal< bool () > *)jarg1;
54883   {
54884     try {
54885       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
54886     } catch (std::out_of_range& e) {
54887       {
54888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54889       };
54890     } catch (std::exception& e) {
54891       {
54892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54893       };
54894     } catch (Dali::DaliException e) {
54895       {
54896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54897       };
54898     } catch (...) {
54899       {
54900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54901       };
54902     }
54903   }
54904
54905   jresult = (unsigned long)result;
54906   return jresult;
54907 }
54908
54909
54910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
54911   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
54912   bool (*arg2)() = (bool (*)()) 0 ;
54913
54914   arg1 = (Dali::Signal< bool () > *)jarg1;
54915   arg2 = (bool (*)())jarg2;
54916   {
54917     try {
54918       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
54919     } catch (std::out_of_range& e) {
54920       {
54921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54922       };
54923     } catch (std::exception& e) {
54924       {
54925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54926       };
54927     } catch (Dali::DaliException e) {
54928       {
54929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54930       };
54931     } catch (...) {
54932       {
54933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54934       };
54935     }
54936   }
54937
54938 }
54939
54940
54941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
54942   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
54943   bool (*arg2)() = (bool (*)()) 0 ;
54944
54945   arg1 = (Dali::Signal< bool () > *)jarg1;
54946   arg2 = (bool (*)())jarg2;
54947   {
54948     try {
54949       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
54950     } catch (std::out_of_range& e) {
54951       {
54952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54953       };
54954     } catch (std::exception& e) {
54955       {
54956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54957       };
54958     } catch (Dali::DaliException e) {
54959       {
54960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54961       };
54962     } catch (...) {
54963       {
54964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54965       };
54966     }
54967   }
54968
54969 }
54970
54971
54972 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
54973   unsigned int jresult ;
54974   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
54975   bool result;
54976
54977   arg1 = (Dali::Signal< bool () > *)jarg1;
54978   {
54979     try {
54980       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
54981     } catch (std::out_of_range& e) {
54982       {
54983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54984       };
54985     } catch (std::exception& e) {
54986       {
54987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54988       };
54989     } catch (Dali::DaliException e) {
54990       {
54991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54992       };
54993     } catch (...) {
54994       {
54995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54996       };
54997     }
54998   }
54999
55000   jresult = result;
55001   return jresult;
55002 }
55003
55004
55005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
55006   void * jresult ;
55007   Dali::Signal< bool () > *result = 0 ;
55008
55009   {
55010     try {
55011       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
55012     } catch (std::out_of_range& e) {
55013       {
55014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55015       };
55016     } catch (std::exception& e) {
55017       {
55018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55019       };
55020     } catch (Dali::DaliException e) {
55021       {
55022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55023       };
55024     } catch (...) {
55025       {
55026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55027       };
55028     }
55029   }
55030
55031   jresult = (void *)result;
55032   return jresult;
55033 }
55034
55035
55036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
55037   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55038
55039   arg1 = (Dali::Signal< bool () > *)jarg1;
55040   {
55041     try {
55042       delete arg1;
55043     } catch (std::out_of_range& e) {
55044       {
55045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55046       };
55047     } catch (std::exception& e) {
55048       {
55049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55050       };
55051     } catch (Dali::DaliException e) {
55052       {
55053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55054       };
55055     } catch (...) {
55056       {
55057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55058       };
55059     }
55060   }
55061
55062 }
55063
55064
55065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
55066   int jresult ;
55067   int result;
55068
55069   {
55070     try {
55071       result = (int)Dali::Toolkit::Visual::Property::TYPE;
55072     } catch (std::out_of_range& e) {
55073       {
55074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55075       };
55076     } catch (std::exception& e) {
55077       {
55078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55079       };
55080     } catch (Dali::DaliException e) {
55081       {
55082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55083       };
55084     } catch (...) {
55085       {
55086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55087       };
55088     }
55089   }
55090
55091   jresult = (int)result;
55092   return jresult;
55093 }
55094
55095
55096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
55097   int jresult ;
55098   int result;
55099
55100   {
55101     try {
55102       result = (int)Dali::Toolkit::Visual::Property::SHADER;
55103     } catch (std::out_of_range& e) {
55104       {
55105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55106       };
55107     } catch (std::exception& e) {
55108       {
55109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55110       };
55111     } catch (Dali::DaliException e) {
55112       {
55113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55114       };
55115     } catch (...) {
55116       {
55117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55118       };
55119     }
55120   }
55121
55122   jresult = (int)result;
55123   return jresult;
55124 }
55125
55126
55127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
55128   int jresult ;
55129   int result;
55130
55131   {
55132     try {
55133       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
55134     } catch (std::out_of_range& e) {
55135       {
55136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55137       };
55138     } catch (std::exception& e) {
55139       {
55140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55141       };
55142     } catch (Dali::DaliException e) {
55143       {
55144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55145       };
55146     } catch (...) {
55147       {
55148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55149       };
55150     }
55151   }
55152
55153   jresult = (int)result;
55154   return jresult;
55155 }
55156
55157
55158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
55159   int jresult ;
55160   int result;
55161
55162   {
55163     try {
55164       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
55165     } catch (std::out_of_range& e) {
55166       {
55167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55168       };
55169     } catch (std::exception& e) {
55170       {
55171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55172       };
55173     } catch (Dali::DaliException e) {
55174       {
55175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55176       };
55177     } catch (...) {
55178       {
55179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55180       };
55181     }
55182   }
55183
55184   jresult = (int)result;
55185   return jresult;
55186 }
55187
55188
55189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
55190   int jresult ;
55191   int result;
55192
55193   {
55194     try {
55195       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
55196     } catch (std::out_of_range& e) {
55197       {
55198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55199       };
55200     } catch (std::exception& e) {
55201       {
55202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55203       };
55204     } catch (Dali::DaliException e) {
55205       {
55206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55207       };
55208     } catch (...) {
55209       {
55210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55211       };
55212     }
55213   }
55214
55215   jresult = (int)result;
55216   return jresult;
55217 }
55218
55219
55220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
55221   int jresult ;
55222   int result;
55223
55224   {
55225     try {
55226       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
55227     } catch (std::out_of_range& e) {
55228       {
55229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55230       };
55231     } catch (std::exception& e) {
55232       {
55233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55234       };
55235     } catch (Dali::DaliException e) {
55236       {
55237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55238       };
55239     } catch (...) {
55240       {
55241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55242       };
55243     }
55244   }
55245
55246   jresult = (int)result;
55247   return jresult;
55248 }
55249
55250
55251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
55252   int jresult ;
55253   int result;
55254
55255   {
55256     try {
55257       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
55258     } catch (std::out_of_range& e) {
55259       {
55260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55261       };
55262     } catch (std::exception& e) {
55263       {
55264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55265       };
55266     } catch (Dali::DaliException e) {
55267       {
55268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55269       };
55270     } catch (...) {
55271       {
55272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55273       };
55274     }
55275   }
55276
55277   jresult = (int)result;
55278   return jresult;
55279 }
55280
55281
55282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
55283   int jresult ;
55284   int result;
55285
55286   {
55287     try {
55288       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
55289     } catch (std::out_of_range& e) {
55290       {
55291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55292       };
55293     } catch (std::exception& e) {
55294       {
55295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55296       };
55297     } catch (Dali::DaliException e) {
55298       {
55299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55300       };
55301     } catch (...) {
55302       {
55303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55304       };
55305     }
55306   }
55307
55308   jresult = (int)result;
55309   return jresult;
55310 }
55311
55312
55313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
55314   int jresult ;
55315   int result;
55316
55317   {
55318     try {
55319       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
55320     } catch (std::out_of_range& e) {
55321       {
55322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55323       };
55324     } catch (std::exception& e) {
55325       {
55326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55327       };
55328     } catch (Dali::DaliException e) {
55329       {
55330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55331       };
55332     } catch (...) {
55333       {
55334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55335       };
55336     }
55337   }
55338
55339   jresult = (int)result;
55340   return jresult;
55341 }
55342
55343
55344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
55345   int jresult ;
55346   int result;
55347
55348   {
55349     try {
55350       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
55351     } catch (std::out_of_range& e) {
55352       {
55353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55354       };
55355     } catch (std::exception& e) {
55356       {
55357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55358       };
55359     } catch (Dali::DaliException e) {
55360       {
55361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55362       };
55363     } catch (...) {
55364       {
55365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55366       };
55367     }
55368   }
55369
55370   jresult = (int)result;
55371   return jresult;
55372 }
55373
55374
55375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
55376   int jresult ;
55377   int result;
55378
55379   {
55380     try {
55381       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
55382     } catch (std::out_of_range& e) {
55383       {
55384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55385       };
55386     } catch (std::exception& e) {
55387       {
55388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55389       };
55390     } catch (Dali::DaliException e) {
55391       {
55392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55393       };
55394     } catch (...) {
55395       {
55396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55397       };
55398     }
55399   }
55400
55401   jresult = (int)result;
55402   return jresult;
55403 }
55404
55405
55406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
55407   int jresult ;
55408   int result;
55409
55410   {
55411     try {
55412       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
55413     } catch (std::out_of_range& e) {
55414       {
55415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55416       };
55417     } catch (std::exception& e) {
55418       {
55419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55420       };
55421     } catch (Dali::DaliException e) {
55422       {
55423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55424       };
55425     } catch (...) {
55426       {
55427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55428       };
55429     }
55430   }
55431
55432   jresult = (int)result;
55433   return jresult;
55434 }
55435
55436
55437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
55438   int jresult ;
55439   int result;
55440
55441   {
55442     try {
55443       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
55444     } catch (std::out_of_range& e) {
55445       {
55446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55447       };
55448     } catch (std::exception& e) {
55449       {
55450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55451       };
55452     } catch (Dali::DaliException e) {
55453       {
55454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55455       };
55456     } catch (...) {
55457       {
55458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55459       };
55460     }
55461   }
55462
55463   jresult = (int)result;
55464   return jresult;
55465 }
55466
55467
55468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
55469   int jresult ;
55470   int result;
55471
55472   {
55473     try {
55474       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
55475     } catch (std::out_of_range& e) {
55476       {
55477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55478       };
55479     } catch (std::exception& e) {
55480       {
55481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55482       };
55483     } catch (Dali::DaliException e) {
55484       {
55485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55486       };
55487     } catch (...) {
55488       {
55489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55490       };
55491     }
55492   }
55493
55494   jresult = (int)result;
55495   return jresult;
55496 }
55497
55498
55499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
55500   int jresult ;
55501   int result;
55502
55503   {
55504     try {
55505       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
55506     } catch (std::out_of_range& e) {
55507       {
55508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55509       };
55510     } catch (std::exception& e) {
55511       {
55512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55513       };
55514     } catch (Dali::DaliException e) {
55515       {
55516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55517       };
55518     } catch (...) {
55519       {
55520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55521       };
55522     }
55523   }
55524
55525   jresult = (int)result;
55526   return jresult;
55527 }
55528
55529
55530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
55531   int jresult ;
55532   int result;
55533
55534   {
55535     try {
55536       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
55537     } catch (std::out_of_range& e) {
55538       {
55539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55540       };
55541     } catch (std::exception& e) {
55542       {
55543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55544       };
55545     } catch (Dali::DaliException e) {
55546       {
55547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55548       };
55549     } catch (...) {
55550       {
55551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55552       };
55553     }
55554   }
55555
55556   jresult = (int)result;
55557   return jresult;
55558 }
55559
55560
55561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
55562   int jresult ;
55563   int result;
55564
55565   {
55566     try {
55567       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
55568     } catch (std::out_of_range& e) {
55569       {
55570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55571       };
55572     } catch (std::exception& e) {
55573       {
55574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55575       };
55576     } catch (Dali::DaliException e) {
55577       {
55578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55579       };
55580     } catch (...) {
55581       {
55582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55583       };
55584     }
55585   }
55586
55587   jresult = (int)result;
55588   return jresult;
55589 }
55590
55591
55592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
55593   int jresult ;
55594   int result;
55595
55596   {
55597     try {
55598       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
55599     } catch (std::out_of_range& e) {
55600       {
55601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55602       };
55603     } catch (std::exception& e) {
55604       {
55605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55606       };
55607     } catch (Dali::DaliException e) {
55608       {
55609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55610       };
55611     } catch (...) {
55612       {
55613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55614       };
55615     }
55616   }
55617
55618   jresult = (int)result;
55619   return jresult;
55620 }
55621
55622
55623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
55624   int jresult ;
55625   int result;
55626
55627   {
55628     try {
55629       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
55630     } catch (std::out_of_range& e) {
55631       {
55632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55633       };
55634     } catch (std::exception& e) {
55635       {
55636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55637       };
55638     } catch (Dali::DaliException e) {
55639       {
55640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55641       };
55642     } catch (...) {
55643       {
55644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55645       };
55646     }
55647   }
55648
55649   jresult = (int)result;
55650   return jresult;
55651 }
55652
55653
55654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
55655   int jresult ;
55656   int result;
55657
55658   {
55659     try {
55660       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
55661     } catch (std::out_of_range& e) {
55662       {
55663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55664       };
55665     } catch (std::exception& e) {
55666       {
55667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55668       };
55669     } catch (Dali::DaliException e) {
55670       {
55671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55672       };
55673     } catch (...) {
55674       {
55675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55676       };
55677     }
55678   }
55679
55680   jresult = (int)result;
55681   return jresult;
55682 }
55683
55684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
55685   int jresult ;
55686   int result;
55687
55688   {
55689     try {
55690       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
55691     } catch (std::out_of_range& e) {
55692       {
55693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55694       };
55695     } catch (std::exception& e) {
55696       {
55697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55698       };
55699     } catch (Dali::DaliException e) {
55700       {
55701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55702       };
55703     } catch (...) {
55704       {
55705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55706       };
55707     }
55708   }
55709
55710   jresult = (int)result;
55711   return jresult;
55712 }
55713
55714
55715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
55716   int jresult ;
55717   int result;
55718   {
55719     try
55720     {
55721       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
55722     } catch (std::out_of_range& e) {
55723       {
55724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55725       };
55726     } catch (std::exception& e) {
55727       {
55728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55729       };
55730     } catch (Dali::DaliException e) {
55731       {
55732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55733       };
55734     } catch (...) {
55735       {
55736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55737       };
55738     }
55739   }
55740
55741   jresult = (int)result;
55742   return jresult;
55743 }
55744
55745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
55746   int jresult ;
55747   int result;
55748   {
55749     try
55750     {
55751       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
55752     } catch (std::out_of_range& e) {
55753       {
55754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55755       };
55756     } catch (std::exception& e) {
55757       {
55758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55759       };
55760     } catch (Dali::DaliException e) {
55761       {
55762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55763       };
55764     } catch (...) {
55765       {
55766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55767       };
55768     }
55769   }
55770
55771   jresult = (int)result;
55772   return jresult;
55773 }
55774
55775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
55776   int jresult ;
55777   int result;
55778   {
55779     try
55780     {
55781       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
55782     } catch (std::out_of_range& e) {
55783       {
55784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55785       };
55786     } catch (std::exception& e) {
55787       {
55788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55789       };
55790     } catch (Dali::DaliException e) {
55791       {
55792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55793       };
55794     } catch (...) {
55795       {
55796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55797       };
55798     }
55799   }
55800
55801   jresult = (int)result;
55802   return jresult;
55803 }
55804
55805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
55806   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
55807 }
55808
55809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
55810   int jresult ;
55811   int result;
55812   {
55813     try
55814     {
55815       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
55816     } catch (std::out_of_range& e) {
55817       {
55818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55819       };
55820     } catch (std::exception& e) {
55821       {
55822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55823       };
55824     } catch (Dali::DaliException e) {
55825       {
55826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55827       };
55828     } catch (...) {
55829       {
55830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55831       };
55832     }
55833   }
55834
55835   jresult = (int)result;
55836   return jresult;
55837 }
55838
55839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
55840   int jresult ;
55841   int result;
55842   {
55843     try
55844     {
55845       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
55846     } catch (std::out_of_range& e) {
55847       {
55848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55849       };
55850     } catch (std::exception& e) {
55851       {
55852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55853       };
55854     } catch (Dali::DaliException e) {
55855       {
55856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55857       };
55858     } catch (...) {
55859       {
55860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55861       };
55862     }
55863   }
55864
55865   jresult = (int)result;
55866   return jresult;
55867 }
55868
55869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
55870   int jresult ;
55871   int result;
55872
55873   {
55874     try {
55875       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
55876     } catch (std::out_of_range& e) {
55877       {
55878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55879       };
55880     } catch (std::exception& e) {
55881       {
55882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55883       };
55884     } catch (Dali::DaliException e) {
55885       {
55886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55887       };
55888     } catch (...) {
55889       {
55890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55891       };
55892     }
55893   }
55894
55895   jresult = (int)result;
55896   return jresult;
55897 }
55898
55899
55900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
55901   int jresult ;
55902   int result;
55903
55904   {
55905     try {
55906       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
55907     } catch (std::out_of_range& e) {
55908       {
55909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55910       };
55911     } catch (std::exception& e) {
55912       {
55913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55914       };
55915     } catch (Dali::DaliException e) {
55916       {
55917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55918       };
55919     } catch (...) {
55920       {
55921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55922       };
55923     }
55924   }
55925
55926   jresult = (int)result;
55927   return jresult;
55928 }
55929
55930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
55931   int jresult ;
55932   int result;
55933   {
55934     try
55935     {
55936       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
55937     } catch (std::out_of_range& e) {
55938       {
55939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55940       };
55941     } catch (std::exception& e) {
55942       {
55943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55944       };
55945     } catch (...) {
55946       {
55947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55948       };
55949     }
55950   }
55951   jresult = (int)result;
55952   return jresult;
55953 }
55954
55955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
55956   int jresult ;
55957   int result;
55958   {
55959     try
55960     {
55961       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
55962     } catch (std::out_of_range& e) {
55963       {
55964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55965       };
55966     } catch (std::exception& e) {
55967       {
55968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55969       };
55970     } catch (...) {
55971       {
55972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55973       };
55974     }
55975   }
55976   jresult = (int)result;
55977   return jresult;
55978 }
55979
55980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
55981   int jresult ;
55982   int result;
55983   {
55984     try
55985     {
55986       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
55987     } catch (std::out_of_range& e) {
55988       {
55989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55990       };
55991     } catch (std::exception& e) {
55992       {
55993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55994       };
55995     } catch (...) {
55996       {
55997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55998       };
55999     }
56000   }
56001   jresult = (int)result;
56002   return jresult;
56003 }
56004
56005
56006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
56007   int jresult ;
56008   int result;
56009   {
56010     try
56011     {
56012       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
56013     } catch (std::out_of_range& e) {
56014       {
56015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56016       };
56017     } catch (std::exception& e) {
56018       {
56019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56020       };
56021     } catch (...) {
56022       {
56023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56024       };
56025     }
56026   }
56027   jresult = (int)result;
56028   return jresult;
56029 }
56030
56031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
56032   int jresult ;
56033   int result;
56034   {
56035     try
56036     {
56037       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
56038     } catch (std::out_of_range& e) {
56039       {
56040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56041       };
56042     } catch (std::exception& e) {
56043       {
56044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56045       };
56046     } catch (...) {
56047       {
56048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56049       };
56050     }
56051   }
56052   jresult = (int)result;
56053   return jresult;
56054 }
56055
56056
56057
56058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
56059   int jresult ;
56060   int result;
56061
56062   {
56063     try {
56064       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
56065     } catch (std::out_of_range& e) {
56066       {
56067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56068       };
56069     } catch (std::exception& e) {
56070       {
56071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56072       };
56073     } catch (Dali::DaliException e) {
56074       {
56075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56076       };
56077     } catch (...) {
56078       {
56079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56080       };
56081     }
56082   }
56083
56084   jresult = (int)result;
56085   return jresult;
56086 }
56087
56088
56089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
56090   int jresult ;
56091   int result;
56092
56093   {
56094     try {
56095       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
56096     } catch (std::out_of_range& e) {
56097       {
56098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56099       };
56100     } catch (std::exception& e) {
56101       {
56102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56103       };
56104     } catch (Dali::DaliException e) {
56105       {
56106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56107       };
56108     } catch (...) {
56109       {
56110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56111       };
56112     }
56113   }
56114
56115   jresult = (int)result;
56116   return jresult;
56117 }
56118
56119
56120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
56121   int jresult ;
56122   int result;
56123
56124   {
56125     try {
56126       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
56127     } catch (std::out_of_range& e) {
56128       {
56129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56130       };
56131     } catch (std::exception& e) {
56132       {
56133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56134       };
56135     } catch (Dali::DaliException e) {
56136       {
56137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56138       };
56139     } catch (...) {
56140       {
56141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56142       };
56143     }
56144   }
56145
56146   jresult = (int)result;
56147   return jresult;
56148 }
56149
56150
56151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
56152   int jresult ;
56153   int result;
56154
56155   {
56156     try {
56157       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
56158     } catch (std::out_of_range& e) {
56159       {
56160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56161       };
56162     } catch (std::exception& e) {
56163       {
56164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56165       };
56166     } catch (Dali::DaliException e) {
56167       {
56168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56169       };
56170     } catch (...) {
56171       {
56172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56173       };
56174     }
56175   }
56176
56177   jresult = (int)result;
56178   return jresult;
56179 }
56180
56181
56182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
56183   int jresult ;
56184   int result;
56185
56186   {
56187     try {
56188       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
56189     } catch (std::out_of_range& e) {
56190       {
56191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56192       };
56193     } catch (std::exception& e) {
56194       {
56195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56196       };
56197     } catch (Dali::DaliException e) {
56198       {
56199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56200       };
56201     } catch (...) {
56202       {
56203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56204       };
56205     }
56206   }
56207
56208   jresult = (int)result;
56209   return jresult;
56210 }
56211
56212
56213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
56214   int jresult ;
56215   int result;
56216
56217   {
56218     try {
56219       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
56220     } catch (std::out_of_range& e) {
56221       {
56222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56223       };
56224     } catch (std::exception& e) {
56225       {
56226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56227       };
56228     } catch (Dali::DaliException e) {
56229       {
56230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56231       };
56232     } catch (...) {
56233       {
56234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56235       };
56236     }
56237   }
56238
56239   jresult = (int)result;
56240   return jresult;
56241 }
56242
56243
56244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
56245   int jresult ;
56246   int result;
56247
56248   {
56249     try {
56250       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
56251     } catch (std::out_of_range& e) {
56252       {
56253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56254       };
56255     } catch (std::exception& e) {
56256       {
56257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56258       };
56259     } catch (Dali::DaliException e) {
56260       {
56261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56262       };
56263     } catch (...) {
56264       {
56265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56266       };
56267     }
56268   }
56269
56270   jresult = (int)result;
56271   return jresult;
56272 }
56273
56274 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
56275   int jresult ;
56276   int result;
56277
56278   {
56279     try {
56280       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
56281     } catch (std::out_of_range& e) {
56282       {
56283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56284       };
56285     } catch (std::exception& e) {
56286       {
56287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56288       };
56289     } catch (...) {
56290       {
56291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56292       };
56293     }
56294   }
56295   jresult = (int)result;
56296   return jresult;
56297 }
56298
56299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
56300   int jresult ;
56301   int result;
56302
56303   {
56304     try {
56305       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
56306     } catch (std::out_of_range& e) {
56307       {
56308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56309       };
56310     } catch (std::exception& e) {
56311       {
56312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56313       };
56314     } catch (Dali::DaliException e) {
56315       {
56316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56317       };
56318     } catch (...) {
56319       {
56320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56321       };
56322     }
56323   }
56324
56325   jresult = (int)result;
56326   return jresult;
56327 }
56328
56329
56330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
56331   int jresult ;
56332   int result;
56333
56334   {
56335     try {
56336       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
56337     } catch (std::out_of_range& e) {
56338       {
56339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56340       };
56341     } catch (std::exception& e) {
56342       {
56343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56344       };
56345     } catch (Dali::DaliException e) {
56346       {
56347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56348       };
56349     } catch (...) {
56350       {
56351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56352       };
56353     }
56354   }
56355
56356   jresult = (int)result;
56357   return jresult;
56358 }
56359
56360
56361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
56362   int jresult ;
56363   int result;
56364
56365   {
56366     try {
56367       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
56368     } catch (std::out_of_range& e) {
56369       {
56370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56371       };
56372     } catch (std::exception& e) {
56373       {
56374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56375       };
56376     } catch (Dali::DaliException e) {
56377       {
56378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56379       };
56380     } catch (...) {
56381       {
56382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56383       };
56384     }
56385   }
56386
56387   jresult = (int)result;
56388   return jresult;
56389 }
56390
56391
56392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
56393   int jresult ;
56394   int result;
56395
56396   {
56397     try {
56398       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
56399     } catch (std::out_of_range& e) {
56400       {
56401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56402       };
56403     } catch (std::exception& e) {
56404       {
56405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56406       };
56407     } catch (Dali::DaliException e) {
56408       {
56409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56410       };
56411     } catch (...) {
56412       {
56413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56414       };
56415     }
56416   }
56417
56418   jresult = (int)result;
56419   return jresult;
56420 }
56421
56422
56423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
56424   int jresult ;
56425   int result;
56426
56427   {
56428     try {
56429       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
56430     } catch (std::out_of_range& e) {
56431       {
56432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56433       };
56434     } catch (std::exception& e) {
56435       {
56436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56437       };
56438     } catch (Dali::DaliException e) {
56439       {
56440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56441       };
56442     } catch (...) {
56443       {
56444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56445       };
56446     }
56447   }
56448
56449   jresult = (int)result;
56450   return jresult;
56451 }
56452
56453
56454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
56455   int jresult ;
56456   int result;
56457
56458   {
56459     try {
56460       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
56461     } catch (std::out_of_range& e) {
56462       {
56463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56464       };
56465     } catch (std::exception& e) {
56466       {
56467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56468       };
56469     } catch (Dali::DaliException e) {
56470       {
56471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56472       };
56473     } catch (...) {
56474       {
56475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56476       };
56477     }
56478   }
56479
56480   jresult = (int)result;
56481   return jresult;
56482 }
56483
56484
56485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
56486   int jresult ;
56487   int result;
56488
56489   {
56490     try {
56491       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
56492     } catch (std::out_of_range& e) {
56493       {
56494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56495       };
56496     } catch (std::exception& e) {
56497       {
56498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56499       };
56500     } catch (Dali::DaliException e) {
56501       {
56502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56503       };
56504     } catch (...) {
56505       {
56506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56507       };
56508     }
56509   }
56510
56511   jresult = (int)result;
56512   return jresult;
56513 }
56514
56515
56516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
56517   int jresult ;
56518   int result;
56519
56520   {
56521     try {
56522       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
56523     } catch (std::out_of_range& e) {
56524       {
56525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56526       };
56527     } catch (std::exception& e) {
56528       {
56529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56530       };
56531     } catch (Dali::DaliException e) {
56532       {
56533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56534       };
56535     } catch (...) {
56536       {
56537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56538       };
56539     }
56540   }
56541
56542   jresult = (int)result;
56543   return jresult;
56544 }
56545
56546
56547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
56548   int jresult ;
56549   int result;
56550
56551   {
56552     try {
56553       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
56554     } catch (std::out_of_range& e) {
56555       {
56556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56557       };
56558     } catch (std::exception& e) {
56559       {
56560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56561       };
56562     } catch (Dali::DaliException e) {
56563       {
56564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56565       };
56566     } catch (...) {
56567       {
56568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56569       };
56570     }
56571   }
56572
56573   jresult = (int)result;
56574   return jresult;
56575 }
56576
56577
56578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
56579   int jresult ;
56580   int result;
56581
56582   {
56583     try {
56584       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
56585     } catch (std::out_of_range& e) {
56586       {
56587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56588       };
56589     } catch (std::exception& e) {
56590       {
56591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56592       };
56593     } catch (Dali::DaliException e) {
56594       {
56595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56596       };
56597     } catch (...) {
56598       {
56599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56600       };
56601     }
56602   }
56603
56604   jresult = (int)result;
56605   return jresult;
56606 }
56607
56608
56609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
56610   int jresult ;
56611   int result;
56612
56613   {
56614     try {
56615       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
56616     } catch (std::out_of_range& e) {
56617       {
56618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56619       };
56620     } catch (std::exception& e) {
56621       {
56622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56623       };
56624     } catch (Dali::DaliException e) {
56625       {
56626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56627       };
56628     } catch (...) {
56629       {
56630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56631       };
56632     }
56633   }
56634
56635   jresult = (int)result;
56636   return jresult;
56637 }
56638
56639
56640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
56641   int jresult ;
56642   int result;
56643
56644   {
56645     try {
56646       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
56647     } catch (std::out_of_range& e) {
56648       {
56649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56650       };
56651     } catch (std::exception& e) {
56652       {
56653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56654       };
56655     } catch (Dali::DaliException e) {
56656       {
56657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56658       };
56659     } catch (...) {
56660       {
56661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56662       };
56663     }
56664   }
56665
56666   jresult = (int)result;
56667   return jresult;
56668 }
56669
56670
56671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
56672   int jresult ;
56673   int result;
56674
56675   {
56676     try {
56677       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
56678     } catch (std::out_of_range& e) {
56679       {
56680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56681       };
56682     } catch (std::exception& e) {
56683       {
56684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56685       };
56686     } catch (Dali::DaliException e) {
56687       {
56688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56689       };
56690     } catch (...) {
56691       {
56692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56693       };
56694     }
56695   }
56696
56697   jresult = (int)result;
56698   return jresult;
56699 }
56700
56701
56702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
56703   int jresult ;
56704   int result;
56705
56706   {
56707     try {
56708       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
56709     } catch (std::out_of_range& e) {
56710       {
56711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56712       };
56713     } catch (std::exception& e) {
56714       {
56715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56716       };
56717     } catch (Dali::DaliException e) {
56718       {
56719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56720       };
56721     } catch (...) {
56722       {
56723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56724       };
56725     }
56726   }
56727
56728   jresult = (int)result;
56729   return jresult;
56730 }
56731
56732
56733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
56734   int jresult ;
56735   int result;
56736
56737   {
56738     try {
56739       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
56740     } catch (std::out_of_range& e) {
56741       {
56742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56743       };
56744     } catch (std::exception& e) {
56745       {
56746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56747       };
56748     } catch (Dali::DaliException e) {
56749       {
56750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56751       };
56752     } catch (...) {
56753       {
56754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56755       };
56756     }
56757   }
56758
56759   jresult = (int)result;
56760   return jresult;
56761 }
56762
56763
56764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
56765   int jresult ;
56766   int result;
56767
56768   {
56769     try {
56770       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
56771     } catch (std::out_of_range& e) {
56772       {
56773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56774       };
56775     } catch (std::exception& e) {
56776       {
56777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56778       };
56779     } catch (Dali::DaliException e) {
56780       {
56781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56782       };
56783     } catch (...) {
56784       {
56785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56786       };
56787     }
56788   }
56789
56790   jresult = (int)result;
56791   return jresult;
56792 }
56793
56794
56795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
56796   int jresult ;
56797   int result;
56798
56799   {
56800     try {
56801       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
56802     } catch (std::out_of_range& e) {
56803       {
56804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56805       };
56806     } catch (std::exception& e) {
56807       {
56808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56809       };
56810     } catch (Dali::DaliException e) {
56811       {
56812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56813       };
56814     } catch (...) {
56815       {
56816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56817       };
56818     }
56819   }
56820
56821   jresult = (int)result;
56822   return jresult;
56823 }
56824
56825
56826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
56827   int jresult ;
56828   int result;
56829
56830   {
56831     try {
56832       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
56833     } catch (std::out_of_range& e) {
56834       {
56835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56836       };
56837     } catch (std::exception& e) {
56838       {
56839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56840       };
56841     } catch (Dali::DaliException e) {
56842       {
56843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56844       };
56845     } catch (...) {
56846       {
56847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56848       };
56849     }
56850   }
56851
56852   jresult = (int)result;
56853   return jresult;
56854 }
56855
56856
56857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
56858   int jresult ;
56859   int result;
56860
56861   {
56862     try {
56863       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
56864     } catch (std::out_of_range& e) {
56865       {
56866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56867       };
56868     } catch (std::exception& e) {
56869       {
56870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56871       };
56872     } catch (Dali::DaliException e) {
56873       {
56874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56875       };
56876     } catch (...) {
56877       {
56878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56879       };
56880     }
56881   }
56882
56883   jresult = (int)result;
56884   return jresult;
56885 }
56886
56887
56888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
56889   int jresult ;
56890   int result;
56891
56892   {
56893     try {
56894       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
56895     } catch (std::out_of_range& e) {
56896       {
56897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56898       };
56899     } catch (std::exception& e) {
56900       {
56901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56902       };
56903     } catch (Dali::DaliException e) {
56904       {
56905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56906       };
56907     } catch (...) {
56908       {
56909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56910       };
56911     }
56912   }
56913
56914   jresult = (int)result;
56915   return jresult;
56916 }
56917
56918
56919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
56920   int jresult ;
56921   int result;
56922
56923   {
56924     try {
56925       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
56926     } catch (std::out_of_range& e) {
56927       {
56928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56929       };
56930     } catch (std::exception& e) {
56931       {
56932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56933       };
56934     } catch (Dali::DaliException e) {
56935       {
56936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56937       };
56938     } catch (...) {
56939       {
56940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56941       };
56942     }
56943   }
56944
56945   jresult = (int)result;
56946   return jresult;
56947 }
56948
56949
56950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
56951   int jresult ;
56952   int result;
56953
56954   {
56955     try {
56956       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
56957     } catch (std::out_of_range& e) {
56958       {
56959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56960       };
56961     } catch (std::exception& e) {
56962       {
56963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56964       };
56965     } catch (Dali::DaliException e) {
56966       {
56967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56968       };
56969     } catch (...) {
56970       {
56971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56972       };
56973     }
56974   }
56975
56976   jresult = (int)result;
56977   return jresult;
56978 }
56979
56980
56981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
56982   int jresult ;
56983   int result;
56984
56985   {
56986     try {
56987       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
56988     } catch (std::out_of_range& e) {
56989       {
56990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56991       };
56992     } catch (std::exception& e) {
56993       {
56994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56995       };
56996     } catch (Dali::DaliException e) {
56997       {
56998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56999       };
57000     } catch (...) {
57001       {
57002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57003       };
57004     }
57005   }
57006
57007   jresult = (int)result;
57008   return jresult;
57009 }
57010
57011
57012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
57013   int jresult ;
57014   int result;
57015
57016   {
57017     try {
57018       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
57019     } catch (std::out_of_range& e) {
57020       {
57021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57022       };
57023     } catch (std::exception& e) {
57024       {
57025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57026       };
57027     } catch (Dali::DaliException e) {
57028       {
57029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57030       };
57031     } catch (...) {
57032       {
57033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57034       };
57035     }
57036   }
57037
57038   jresult = (int)result;
57039   return jresult;
57040 }
57041
57042
57043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
57044   int jresult ;
57045   int result;
57046
57047   {
57048     try {
57049       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
57050     } catch (std::out_of_range& e) {
57051       {
57052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57053       };
57054     } catch (std::exception& e) {
57055       {
57056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57057       };
57058     } catch (Dali::DaliException e) {
57059       {
57060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57061       };
57062     } catch (...) {
57063       {
57064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57065       };
57066     }
57067   }
57068
57069   jresult = (int)result;
57070   return jresult;
57071 }
57072
57073
57074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
57075   int jresult ;
57076   int result;
57077
57078   {
57079     try {
57080       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
57081     } catch (std::out_of_range& e) {
57082       {
57083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57084       };
57085     } catch (std::exception& e) {
57086       {
57087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57088       };
57089     } catch (Dali::DaliException e) {
57090       {
57091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57092       };
57093     } catch (...) {
57094       {
57095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57096       };
57097     }
57098   }
57099
57100   jresult = (int)result;
57101   return jresult;
57102 }
57103
57104
57105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
57106   int jresult ;
57107   int result;
57108
57109   {
57110     try {
57111       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
57112     } catch (std::out_of_range& e) {
57113       {
57114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57115       };
57116     } catch (std::exception& e) {
57117       {
57118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57119       };
57120     } catch (Dali::DaliException e) {
57121       {
57122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57123       };
57124     } catch (...) {
57125       {
57126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57127       };
57128     }
57129   }
57130
57131   jresult = (int)result;
57132   return jresult;
57133 }
57134
57135
57136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
57137   int jresult ;
57138   int result;
57139
57140   {
57141     try {
57142       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
57143     } catch (std::out_of_range& e) {
57144       {
57145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57146       };
57147     } catch (std::exception& e) {
57148       {
57149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57150       };
57151     } catch (Dali::DaliException e) {
57152       {
57153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57154       };
57155     } catch (...) {
57156       {
57157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57158       };
57159     }
57160   }
57161
57162   jresult = (int)result;
57163   return jresult;
57164 }
57165
57166
57167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
57168   void * jresult ;
57169   Dali::Toolkit::Builder *result = 0 ;
57170
57171   {
57172     try {
57173       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
57174     } catch (std::out_of_range& e) {
57175       {
57176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57177       };
57178     } catch (std::exception& e) {
57179       {
57180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57181       };
57182     } catch (Dali::DaliException e) {
57183       {
57184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57185       };
57186     } catch (...) {
57187       {
57188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57189       };
57190     }
57191   }
57192
57193   jresult = (void *)result;
57194   return jresult;
57195 }
57196
57197
57198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
57199   void * jresult ;
57200   Dali::Toolkit::Builder result;
57201
57202   {
57203     try {
57204       result = Dali::Toolkit::Builder::New();
57205     } catch (std::out_of_range& e) {
57206       {
57207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57208       };
57209     } catch (std::exception& e) {
57210       {
57211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57212       };
57213     } catch (Dali::DaliException e) {
57214       {
57215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57216       };
57217     } catch (...) {
57218       {
57219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57220       };
57221     }
57222   }
57223
57224   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
57225   return jresult;
57226 }
57227
57228
57229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
57230   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57231
57232   arg1 = (Dali::Toolkit::Builder *)jarg1;
57233   {
57234     try {
57235       delete arg1;
57236     } catch (std::out_of_range& e) {
57237       {
57238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57239       };
57240     } catch (std::exception& e) {
57241       {
57242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57243       };
57244     } catch (Dali::DaliException e) {
57245       {
57246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57247       };
57248     } catch (...) {
57249       {
57250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57251       };
57252     }
57253   }
57254
57255 }
57256
57257
57258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
57259   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57260   std::string *arg2 = 0 ;
57261   Dali::Toolkit::Builder::UIFormat arg3 ;
57262
57263   arg1 = (Dali::Toolkit::Builder *)jarg1;
57264   if (!jarg2) {
57265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57266     return ;
57267   }
57268   std::string arg2_str(jarg2);
57269   arg2 = &arg2_str;
57270   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
57271   {
57272     try {
57273       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
57274     } catch (std::out_of_range& e) {
57275       {
57276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57277       };
57278     } catch (std::exception& e) {
57279       {
57280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57281       };
57282     } catch (Dali::DaliException e) {
57283       {
57284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57285       };
57286     } catch (...) {
57287       {
57288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57289       };
57290     }
57291   }
57292
57293
57294   //argout typemap for const std::string&
57295
57296 }
57297
57298
57299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
57300   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57301   std::string *arg2 = 0 ;
57302
57303   arg1 = (Dali::Toolkit::Builder *)jarg1;
57304   if (!jarg2) {
57305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57306     return ;
57307   }
57308   std::string arg2_str(jarg2);
57309   arg2 = &arg2_str;
57310   {
57311     try {
57312       (arg1)->LoadFromString((std::string const &)*arg2);
57313     } catch (std::out_of_range& e) {
57314       {
57315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57316       };
57317     } catch (std::exception& e) {
57318       {
57319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57320       };
57321     } catch (Dali::DaliException e) {
57322       {
57323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57324       };
57325     } catch (...) {
57326       {
57327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57328       };
57329     }
57330   }
57331
57332
57333   //argout typemap for const std::string&
57334
57335 }
57336
57337
57338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
57339   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57340   Dali::Property::Map *arg2 = 0 ;
57341
57342   arg1 = (Dali::Toolkit::Builder *)jarg1;
57343   arg2 = (Dali::Property::Map *)jarg2;
57344   if (!arg2) {
57345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57346     return ;
57347   }
57348   {
57349     try {
57350       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
57351     } catch (std::out_of_range& e) {
57352       {
57353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57354       };
57355     } catch (std::exception& e) {
57356       {
57357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57358       };
57359     } catch (Dali::DaliException e) {
57360       {
57361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57362       };
57363     } catch (...) {
57364       {
57365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57366       };
57367     }
57368   }
57369
57370 }
57371
57372
57373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
57374   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57375   std::string *arg2 = 0 ;
57376   Dali::Property::Value *arg3 = 0 ;
57377
57378   arg1 = (Dali::Toolkit::Builder *)jarg1;
57379   if (!jarg2) {
57380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57381     return ;
57382   }
57383   std::string arg2_str(jarg2);
57384   arg2 = &arg2_str;
57385   arg3 = (Dali::Property::Value *)jarg3;
57386   if (!arg3) {
57387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
57388     return ;
57389   }
57390   {
57391     try {
57392       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
57393     } catch (std::out_of_range& e) {
57394       {
57395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57396       };
57397     } catch (std::exception& e) {
57398       {
57399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57400       };
57401     } catch (Dali::DaliException e) {
57402       {
57403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57404       };
57405     } catch (...) {
57406       {
57407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57408       };
57409     }
57410   }
57411
57412
57413   //argout typemap for const std::string&
57414
57415 }
57416
57417
57418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
57419   void * jresult ;
57420   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57421   Dali::Property::Map *result = 0 ;
57422
57423   arg1 = (Dali::Toolkit::Builder *)jarg1;
57424   {
57425     try {
57426       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
57427     } catch (std::out_of_range& e) {
57428       {
57429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57430       };
57431     } catch (std::exception& e) {
57432       {
57433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57434       };
57435     } catch (Dali::DaliException e) {
57436       {
57437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57438       };
57439     } catch (...) {
57440       {
57441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57442       };
57443     }
57444   }
57445
57446   jresult = (void *)result;
57447   return jresult;
57448 }
57449
57450
57451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
57452   void * jresult ;
57453   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57454   std::string *arg2 = 0 ;
57455   Dali::Property::Value *result = 0 ;
57456
57457   arg1 = (Dali::Toolkit::Builder *)jarg1;
57458   if (!jarg2) {
57459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57460     return 0;
57461   }
57462   std::string arg2_str(jarg2);
57463   arg2 = &arg2_str;
57464   {
57465     try {
57466       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
57467     } catch (std::out_of_range& e) {
57468       {
57469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57470       };
57471     } catch (std::exception& e) {
57472       {
57473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57474       };
57475     } catch (Dali::DaliException e) {
57476       {
57477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57478       };
57479     } catch (...) {
57480       {
57481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57482       };
57483     }
57484   }
57485
57486   jresult = (void *)result;
57487
57488   //argout typemap for const std::string&
57489
57490   return jresult;
57491 }
57492
57493
57494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
57495   void * jresult ;
57496   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57497   std::string *arg2 = 0 ;
57498   Dali::Animation result;
57499
57500   arg1 = (Dali::Toolkit::Builder *)jarg1;
57501   if (!jarg2) {
57502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57503     return 0;
57504   }
57505   std::string arg2_str(jarg2);
57506   arg2 = &arg2_str;
57507   {
57508     try {
57509       result = (arg1)->CreateAnimation((std::string const &)*arg2);
57510     } catch (std::out_of_range& e) {
57511       {
57512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57513       };
57514     } catch (std::exception& e) {
57515       {
57516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57517       };
57518     } catch (Dali::DaliException e) {
57519       {
57520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57521       };
57522     } catch (...) {
57523       {
57524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57525       };
57526     }
57527   }
57528
57529   jresult = new Dali::Animation((const Dali::Animation &)result);
57530
57531   //argout typemap for const std::string&
57532
57533   return jresult;
57534 }
57535
57536
57537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57538   void * jresult ;
57539   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57540   std::string *arg2 = 0 ;
57541   Dali::Property::Map *arg3 = 0 ;
57542   Dali::Animation result;
57543
57544   arg1 = (Dali::Toolkit::Builder *)jarg1;
57545   if (!jarg2) {
57546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57547     return 0;
57548   }
57549   std::string arg2_str(jarg2);
57550   arg2 = &arg2_str;
57551   arg3 = (Dali::Property::Map *)jarg3;
57552   if (!arg3) {
57553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57554     return 0;
57555   }
57556   {
57557     try {
57558       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57559     } catch (std::out_of_range& e) {
57560       {
57561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57562       };
57563     } catch (std::exception& e) {
57564       {
57565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57566       };
57567     } catch (Dali::DaliException e) {
57568       {
57569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57570       };
57571     } catch (...) {
57572       {
57573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57574       };
57575     }
57576   }
57577
57578   jresult = new Dali::Animation((const Dali::Animation &)result);
57579
57580   //argout typemap for const std::string&
57581
57582   return jresult;
57583 }
57584
57585
57586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
57587   void * jresult ;
57588   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57589   std::string *arg2 = 0 ;
57590   Dali::Actor arg3 ;
57591   Dali::Actor *argp3 ;
57592   Dali::Animation result;
57593
57594   arg1 = (Dali::Toolkit::Builder *)jarg1;
57595   if (!jarg2) {
57596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57597     return 0;
57598   }
57599   std::string arg2_str(jarg2);
57600   arg2 = &arg2_str;
57601   argp3 = (Dali::Actor *)jarg3;
57602   if (!argp3) {
57603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57604     return 0;
57605   }
57606   arg3 = *argp3;
57607   {
57608     try {
57609       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
57610     } catch (std::out_of_range& e) {
57611       {
57612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57613       };
57614     } catch (std::exception& e) {
57615       {
57616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57617       };
57618     } catch (Dali::DaliException e) {
57619       {
57620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57621       };
57622     } catch (...) {
57623       {
57624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57625       };
57626     }
57627   }
57628
57629   jresult = new Dali::Animation((const Dali::Animation &)result);
57630
57631   //argout typemap for const std::string&
57632
57633   return jresult;
57634 }
57635
57636
57637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
57638   void * jresult ;
57639   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57640   std::string *arg2 = 0 ;
57641   Dali::Property::Map *arg3 = 0 ;
57642   Dali::Actor arg4 ;
57643   Dali::Actor *argp4 ;
57644   Dali::Animation result;
57645
57646   arg1 = (Dali::Toolkit::Builder *)jarg1;
57647   if (!jarg2) {
57648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57649     return 0;
57650   }
57651   std::string arg2_str(jarg2);
57652   arg2 = &arg2_str;
57653   arg3 = (Dali::Property::Map *)jarg3;
57654   if (!arg3) {
57655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57656     return 0;
57657   }
57658   argp4 = (Dali::Actor *)jarg4;
57659   if (!argp4) {
57660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57661     return 0;
57662   }
57663   arg4 = *argp4;
57664   {
57665     try {
57666       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
57667     } catch (std::out_of_range& e) {
57668       {
57669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57670       };
57671     } catch (std::exception& e) {
57672       {
57673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57674       };
57675     } catch (Dali::DaliException e) {
57676       {
57677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57678       };
57679     } catch (...) {
57680       {
57681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57682       };
57683     }
57684   }
57685
57686   jresult = new Dali::Animation((const Dali::Animation &)result);
57687
57688   //argout typemap for const std::string&
57689
57690   return jresult;
57691 }
57692
57693
57694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
57695   void * jresult ;
57696   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57697   std::string *arg2 = 0 ;
57698   Dali::BaseHandle 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   {
57708     try {
57709       result = (arg1)->Create((std::string const &)*arg2);
57710     } catch (std::out_of_range& e) {
57711       {
57712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57713       };
57714     } catch (std::exception& e) {
57715       {
57716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57717       };
57718     } catch (Dali::DaliException e) {
57719       {
57720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57721       };
57722     } catch (...) {
57723       {
57724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57725       };
57726     }
57727   }
57728
57729   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57730
57731   //argout typemap for const std::string&
57732
57733   return jresult;
57734 }
57735
57736
57737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57738   void * jresult ;
57739   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57740   std::string *arg2 = 0 ;
57741   Dali::Property::Map *arg3 = 0 ;
57742   Dali::BaseHandle result;
57743
57744   arg1 = (Dali::Toolkit::Builder *)jarg1;
57745   if (!jarg2) {
57746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57747     return 0;
57748   }
57749   std::string arg2_str(jarg2);
57750   arg2 = &arg2_str;
57751   arg3 = (Dali::Property::Map *)jarg3;
57752   if (!arg3) {
57753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57754     return 0;
57755   }
57756   {
57757     try {
57758       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57759     } catch (std::out_of_range& e) {
57760       {
57761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57762       };
57763     } catch (std::exception& e) {
57764       {
57765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57766       };
57767     } catch (Dali::DaliException e) {
57768       {
57769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57770       };
57771     } catch (...) {
57772       {
57773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57774       };
57775     }
57776   }
57777
57778   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57779
57780   //argout typemap for const std::string&
57781
57782   return jresult;
57783 }
57784
57785
57786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
57787   void * jresult ;
57788   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57789   std::string *arg2 = 0 ;
57790   Dali::BaseHandle result;
57791
57792   arg1 = (Dali::Toolkit::Builder *)jarg1;
57793   if (!jarg2) {
57794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57795     return 0;
57796   }
57797   std::string arg2_str(jarg2);
57798   arg2 = &arg2_str;
57799   {
57800     try {
57801       result = (arg1)->CreateFromJson((std::string const &)*arg2);
57802     } catch (std::out_of_range& e) {
57803       {
57804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57805       };
57806     } catch (std::exception& e) {
57807       {
57808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57809       };
57810     } catch (Dali::DaliException e) {
57811       {
57812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57813       };
57814     } catch (...) {
57815       {
57816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57817       };
57818     }
57819   }
57820
57821   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57822
57823   //argout typemap for const std::string&
57824
57825   return jresult;
57826 }
57827
57828
57829 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
57830   unsigned int jresult ;
57831   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57832   std::string *arg2 = 0 ;
57833   Dali::Handle *arg3 = 0 ;
57834   bool result;
57835
57836   arg1 = (Dali::Toolkit::Builder *)jarg1;
57837   if (!jarg2) {
57838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57839     return 0;
57840   }
57841   std::string arg2_str(jarg2);
57842   arg2 = &arg2_str;
57843   arg3 = (Dali::Handle *)jarg3;
57844   if (!arg3) {
57845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
57846     return 0;
57847   }
57848   {
57849     try {
57850       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
57851     } catch (std::out_of_range& e) {
57852       {
57853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57854       };
57855     } catch (std::exception& e) {
57856       {
57857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57858       };
57859     } catch (Dali::DaliException e) {
57860       {
57861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57862       };
57863     } catch (...) {
57864       {
57865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57866       };
57867     }
57868   }
57869
57870   jresult = result;
57871
57872   //argout typemap for const std::string&
57873
57874   return jresult;
57875 }
57876
57877
57878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
57879   unsigned int jresult ;
57880   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57881   Dali::Handle *arg2 = 0 ;
57882   std::string *arg3 = 0 ;
57883   bool result;
57884
57885   arg1 = (Dali::Toolkit::Builder *)jarg1;
57886   arg2 = (Dali::Handle *)jarg2;
57887   if (!arg2) {
57888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
57889     return 0;
57890   }
57891   if (!jarg3) {
57892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57893     return 0;
57894   }
57895   std::string arg3_str(jarg3);
57896   arg3 = &arg3_str;
57897   {
57898     try {
57899       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
57900     } catch (std::out_of_range& e) {
57901       {
57902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57903       };
57904     } catch (std::exception& e) {
57905       {
57906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57907       };
57908     } catch (Dali::DaliException e) {
57909       {
57910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57911       };
57912     } catch (...) {
57913       {
57914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57915       };
57916     }
57917   }
57918
57919   jresult = result;
57920
57921   //argout typemap for const std::string&
57922
57923   return jresult;
57924 }
57925
57926
57927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
57928   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57929   Dali::Actor arg2 ;
57930   Dali::Actor *argp2 ;
57931
57932   arg1 = (Dali::Toolkit::Builder *)jarg1;
57933   argp2 = (Dali::Actor *)jarg2;
57934   if (!argp2) {
57935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57936     return ;
57937   }
57938   arg2 = *argp2;
57939   {
57940     try {
57941       (arg1)->AddActors(arg2);
57942     } catch (std::out_of_range& e) {
57943       {
57944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57945       };
57946     } catch (std::exception& e) {
57947       {
57948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57949       };
57950     } catch (Dali::DaliException e) {
57951       {
57952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57953       };
57954     } catch (...) {
57955       {
57956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57957       };
57958     }
57959   }
57960
57961 }
57962
57963
57964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57965   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57966   std::string *arg2 = 0 ;
57967   Dali::Actor arg3 ;
57968   Dali::Actor *argp3 ;
57969
57970   arg1 = (Dali::Toolkit::Builder *)jarg1;
57971   if (!jarg2) {
57972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57973     return ;
57974   }
57975   std::string arg2_str(jarg2);
57976   arg2 = &arg2_str;
57977   argp3 = (Dali::Actor *)jarg3;
57978   if (!argp3) {
57979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57980     return ;
57981   }
57982   arg3 = *argp3;
57983   {
57984     try {
57985       (arg1)->AddActors((std::string const &)*arg2,arg3);
57986     } catch (std::out_of_range& e) {
57987       {
57988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57989       };
57990     } catch (std::exception& e) {
57991       {
57992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57993       };
57994     } catch (Dali::DaliException e) {
57995       {
57996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57997       };
57998     } catch (...) {
57999       {
58000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58001       };
58002     }
58003   }
58004
58005
58006   //argout typemap for const std::string&
58007
58008 }
58009
58010
58011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
58012   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58013   std::string *arg2 = 0 ;
58014
58015   arg1 = (Dali::Toolkit::Builder *)jarg1;
58016   if (!jarg2) {
58017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58018     return ;
58019   }
58020   std::string arg2_str(jarg2);
58021   arg2 = &arg2_str;
58022   {
58023     try {
58024       (arg1)->CreateRenderTask((std::string const &)*arg2);
58025     } catch (std::out_of_range& e) {
58026       {
58027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58028       };
58029     } catch (std::exception& e) {
58030       {
58031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58032       };
58033     } catch (Dali::DaliException e) {
58034       {
58035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58036       };
58037     } catch (...) {
58038       {
58039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58040       };
58041     }
58042   }
58043
58044
58045   //argout typemap for const std::string&
58046
58047 }
58048
58049
58050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
58051   void * jresult ;
58052   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58053   std::string *arg2 = 0 ;
58054   Dali::Path result;
58055
58056   arg1 = (Dali::Toolkit::Builder *)jarg1;
58057   if (!jarg2) {
58058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58059     return 0;
58060   }
58061   std::string arg2_str(jarg2);
58062   arg2 = &arg2_str;
58063   {
58064     try {
58065       result = (arg1)->GetPath((std::string const &)*arg2);
58066     } catch (std::out_of_range& e) {
58067       {
58068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58069       };
58070     } catch (std::exception& e) {
58071       {
58072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58073       };
58074     } catch (Dali::DaliException e) {
58075       {
58076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58077       };
58078     } catch (...) {
58079       {
58080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58081       };
58082     }
58083   }
58084
58085   jresult = new Dali::Path((const Dali::Path &)result);
58086
58087   //argout typemap for const std::string&
58088
58089   return jresult;
58090 }
58091
58092
58093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
58094   void * jresult ;
58095   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58096   std::string *arg2 = 0 ;
58097   Dali::PathConstrainer result;
58098
58099   arg1 = (Dali::Toolkit::Builder *)jarg1;
58100   if (!jarg2) {
58101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58102     return 0;
58103   }
58104   std::string arg2_str(jarg2);
58105   arg2 = &arg2_str;
58106   {
58107     try {
58108       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
58109     } catch (std::out_of_range& e) {
58110       {
58111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58112       };
58113     } catch (std::exception& e) {
58114       {
58115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58116       };
58117     } catch (Dali::DaliException e) {
58118       {
58119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58120       };
58121     } catch (...) {
58122       {
58123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58124       };
58125     }
58126   }
58127
58128   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
58129
58130   //argout typemap for const std::string&
58131
58132   return jresult;
58133 }
58134
58135
58136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
58137   void * jresult ;
58138   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58139   std::string *arg2 = 0 ;
58140   Dali::LinearConstrainer result;
58141
58142   arg1 = (Dali::Toolkit::Builder *)jarg1;
58143   if (!jarg2) {
58144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58145     return 0;
58146   }
58147   std::string arg2_str(jarg2);
58148   arg2 = &arg2_str;
58149   {
58150     try {
58151       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
58152     } catch (std::out_of_range& e) {
58153       {
58154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58155       };
58156     } catch (std::exception& e) {
58157       {
58158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58159       };
58160     } catch (Dali::DaliException e) {
58161       {
58162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58163       };
58164     } catch (...) {
58165       {
58166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58167       };
58168     }
58169   }
58170
58171   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
58172
58173   //argout typemap for const std::string&
58174
58175   return jresult;
58176 }
58177
58178
58179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
58180   void * jresult ;
58181   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58182   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
58183
58184   arg1 = (Dali::Toolkit::Builder *)jarg1;
58185   {
58186     try {
58187       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
58188     } catch (std::out_of_range& e) {
58189       {
58190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58191       };
58192     } catch (std::exception& e) {
58193       {
58194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58195       };
58196     } catch (Dali::DaliException e) {
58197       {
58198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58199       };
58200     } catch (...) {
58201       {
58202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58203       };
58204     }
58205   }
58206
58207   jresult = (void *)result;
58208   return jresult;
58209 }
58210
58211
58212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
58213   void * jresult ;
58214   Dali::Toolkit::TransitionData *result = 0 ;
58215
58216   {
58217     try {
58218       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
58219     } catch (std::out_of_range& e) {
58220       {
58221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58222       };
58223     } catch (std::exception& e) {
58224       {
58225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58226       };
58227     } catch (Dali::DaliException e) {
58228       {
58229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58230       };
58231     } catch (...) {
58232       {
58233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58234       };
58235     }
58236   }
58237
58238   jresult = (void *)result;
58239   return jresult;
58240 }
58241
58242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
58243   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58244
58245   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58246   {
58247     try {
58248       delete arg1;
58249     } catch (std::out_of_range& e) {
58250       {
58251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58252       };
58253     } catch (std::exception& e) {
58254       {
58255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58256       };
58257     } catch (Dali::DaliException e) {
58258       {
58259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58260       };
58261     } catch (...) {
58262       {
58263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58264       };
58265     }
58266   }
58267
58268 }
58269
58270
58271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
58272   void * jresult ;
58273   Dali::Property::Map *arg1 = 0 ;
58274   Dali::Toolkit::TransitionData result;
58275
58276   arg1 = (Dali::Property::Map *)jarg1;
58277   if (!arg1) {
58278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58279     return 0;
58280   }
58281   {
58282     try {
58283       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
58284     } catch (std::out_of_range& e) {
58285       {
58286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58287       };
58288     } catch (std::exception& e) {
58289       {
58290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58291       };
58292     } catch (Dali::DaliException e) {
58293       {
58294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58295       };
58296     } catch (...) {
58297       {
58298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58299       };
58300     }
58301   }
58302
58303   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58304   return jresult;
58305 }
58306
58307
58308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
58309   void * jresult ;
58310   Dali::Property::Array *arg1 = 0 ;
58311   Dali::Toolkit::TransitionData result;
58312
58313   arg1 = (Dali::Property::Array *)jarg1;
58314   if (!arg1) {
58315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
58316     return 0;
58317   }
58318   {
58319     try {
58320       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
58321     } catch (std::out_of_range& e) {
58322       {
58323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58324       };
58325     } catch (std::exception& e) {
58326       {
58327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58328       };
58329     } catch (Dali::DaliException e) {
58330       {
58331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58332       };
58333     } catch (...) {
58334       {
58335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58336       };
58337     }
58338   }
58339
58340   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58341   return jresult;
58342 }
58343
58344
58345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
58346   void * jresult ;
58347   Dali::BaseHandle arg1 ;
58348   Dali::BaseHandle *argp1 ;
58349   Dali::Toolkit::TransitionData result;
58350
58351   argp1 = (Dali::BaseHandle *)jarg1;
58352   if (!argp1) {
58353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58354     return 0;
58355   }
58356   arg1 = *argp1;
58357   {
58358     try {
58359       result = Dali::Toolkit::TransitionData::DownCast(arg1);
58360     } catch (std::out_of_range& e) {
58361       {
58362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58363       };
58364     } catch (std::exception& e) {
58365       {
58366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58367       };
58368     } catch (Dali::DaliException e) {
58369       {
58370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58371       };
58372     } catch (...) {
58373       {
58374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58375       };
58376     }
58377   }
58378
58379   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58380   return jresult;
58381 }
58382
58383
58384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
58385   void * jresult ;
58386   Dali::Toolkit::TransitionData *arg1 = 0 ;
58387   Dali::Toolkit::TransitionData *result = 0 ;
58388
58389   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58390   if (!arg1) {
58391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58392     return 0;
58393   }
58394   {
58395     try {
58396       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
58397     } catch (std::out_of_range& e) {
58398       {
58399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58400       };
58401     } catch (std::exception& e) {
58402       {
58403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58404       };
58405     } catch (Dali::DaliException e) {
58406       {
58407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58408       };
58409     } catch (...) {
58410       {
58411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58412       };
58413     }
58414   }
58415
58416   jresult = (void *)result;
58417   return jresult;
58418 }
58419
58420
58421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
58422   void * jresult ;
58423   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58424   Dali::Toolkit::TransitionData *arg2 = 0 ;
58425   Dali::Toolkit::TransitionData *result = 0 ;
58426
58427   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58428   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58429   if (!arg2) {
58430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58431     return 0;
58432   }
58433   {
58434     try {
58435       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
58436     } catch (std::out_of_range& e) {
58437       {
58438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58439       };
58440     } catch (std::exception& e) {
58441       {
58442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58443       };
58444     } catch (Dali::DaliException e) {
58445       {
58446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58447       };
58448     } catch (...) {
58449       {
58450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58451       };
58452     }
58453   }
58454
58455   jresult = (void *)result;
58456   return jresult;
58457 }
58458
58459
58460 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
58461   unsigned long jresult ;
58462   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58463   size_t result;
58464
58465   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58466   {
58467     try {
58468       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
58469     } catch (std::out_of_range& e) {
58470       {
58471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58472       };
58473     } catch (std::exception& e) {
58474       {
58475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58476       };
58477     } catch (Dali::DaliException e) {
58478       {
58479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58480       };
58481     } catch (...) {
58482       {
58483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58484       };
58485     }
58486   }
58487
58488   jresult = (unsigned long)result;
58489   return jresult;
58490 }
58491
58492
58493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
58494   void * jresult ;
58495   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58496   size_t arg2 ;
58497   Dali::Property::Map result;
58498
58499   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58500   arg2 = (size_t)jarg2;
58501   {
58502     try {
58503       result = (arg1)->GetAnimatorAt(arg2);
58504     } catch (std::out_of_range& e) {
58505       {
58506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58507       };
58508     } catch (std::exception& e) {
58509       {
58510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58511       };
58512     } catch (Dali::DaliException e) {
58513       {
58514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58515       };
58516     } catch (...) {
58517       {
58518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58519       };
58520     }
58521   }
58522
58523   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
58524   return jresult;
58525 }
58526
58527
58528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
58529   int jresult ;
58530   int result;
58531
58532   {
58533     try {
58534       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
58535     } catch (std::out_of_range& e) {
58536       {
58537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58538       };
58539     } catch (std::exception& e) {
58540       {
58541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58542       };
58543     } catch (Dali::DaliException e) {
58544       {
58545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58546       };
58547     } catch (...) {
58548       {
58549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58550       };
58551     }
58552   }
58553
58554   jresult = (int)result;
58555   return jresult;
58556 }
58557
58558
58559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
58560   int jresult ;
58561   int result;
58562
58563   {
58564     try {
58565       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
58566     } catch (std::out_of_range& e) {
58567       {
58568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58569       };
58570     } catch (std::exception& e) {
58571       {
58572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58573       };
58574     } catch (Dali::DaliException e) {
58575       {
58576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58577       };
58578     } catch (...) {
58579       {
58580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58581       };
58582     }
58583   }
58584
58585   jresult = (int)result;
58586   return jresult;
58587 }
58588
58589
58590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
58591   int jresult ;
58592   int result;
58593
58594   {
58595     try {
58596       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
58597     } catch (std::out_of_range& e) {
58598       {
58599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58600       };
58601     } catch (std::exception& e) {
58602       {
58603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58604       };
58605     } catch (Dali::DaliException e) {
58606       {
58607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58608       };
58609     } catch (...) {
58610       {
58611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58612       };
58613     }
58614   }
58615
58616   jresult = (int)result;
58617   return jresult;
58618 }
58619
58620
58621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
58622   int jresult ;
58623   int result;
58624
58625   {
58626     try {
58627       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
58628     } catch (std::out_of_range& e) {
58629       {
58630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58631       };
58632     } catch (std::exception& e) {
58633       {
58634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58635       };
58636     } catch (Dali::DaliException e) {
58637       {
58638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58639       };
58640     } catch (...) {
58641       {
58642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58643       };
58644     }
58645   }
58646
58647   jresult = (int)result;
58648   return jresult;
58649 }
58650
58651
58652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
58653   int jresult ;
58654   int result;
58655
58656   {
58657     try {
58658       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
58659     } catch (std::out_of_range& e) {
58660       {
58661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58662       };
58663     } catch (std::exception& e) {
58664       {
58665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58666       };
58667     } catch (Dali::DaliException e) {
58668       {
58669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58670       };
58671     } catch (...) {
58672       {
58673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58674       };
58675     }
58676   }
58677
58678   jresult = (int)result;
58679   return jresult;
58680 }
58681
58682
58683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
58684   int jresult ;
58685   int result;
58686
58687   {
58688     try {
58689       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
58690     } catch (std::out_of_range& e) {
58691       {
58692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58693       };
58694     } catch (std::exception& e) {
58695       {
58696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58697       };
58698     } catch (Dali::DaliException e) {
58699       {
58700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58701       };
58702     } catch (...) {
58703       {
58704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58705       };
58706     }
58707   }
58708
58709   jresult = (int)result;
58710   return jresult;
58711 }
58712
58713
58714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
58715   int jresult ;
58716   int result;
58717
58718   {
58719     try {
58720       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
58721     } catch (std::out_of_range& e) {
58722       {
58723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58724       };
58725     } catch (std::exception& e) {
58726       {
58727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58728       };
58729     } catch (Dali::DaliException e) {
58730       {
58731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58732       };
58733     } catch (...) {
58734       {
58735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58736       };
58737     }
58738   }
58739
58740   jresult = (int)result;
58741   return jresult;
58742 }
58743
58744
58745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
58746   int jresult ;
58747   int result;
58748
58749   {
58750     try {
58751       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
58752     } catch (std::out_of_range& e) {
58753       {
58754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58755       };
58756     } catch (std::exception& e) {
58757       {
58758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58759       };
58760     } catch (Dali::DaliException e) {
58761       {
58762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58763       };
58764     } catch (...) {
58765       {
58766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58767       };
58768     }
58769   }
58770
58771   jresult = (int)result;
58772   return jresult;
58773 }
58774
58775
58776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
58777   int jresult ;
58778   int result;
58779
58780   {
58781     try {
58782       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
58783     } catch (std::out_of_range& e) {
58784       {
58785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58786       };
58787     } catch (std::exception& e) {
58788       {
58789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58790       };
58791     } catch (Dali::DaliException e) {
58792       {
58793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58794       };
58795     } catch (...) {
58796       {
58797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58798       };
58799     }
58800   }
58801
58802   jresult = (int)result;
58803   return jresult;
58804 }
58805
58806
58807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
58808   int jresult ;
58809   int result;
58810
58811   {
58812     try {
58813       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
58814     } catch (std::out_of_range& e) {
58815       {
58816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58817       };
58818     } catch (std::exception& e) {
58819       {
58820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58821       };
58822     } catch (Dali::DaliException e) {
58823       {
58824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58825       };
58826     } catch (...) {
58827       {
58828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58829       };
58830     }
58831   }
58832
58833   jresult = (int)result;
58834   return jresult;
58835 }
58836
58837
58838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
58839   int jresult ;
58840   int result;
58841
58842   {
58843     try {
58844       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
58845     } catch (std::out_of_range& e) {
58846       {
58847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58848       };
58849     } catch (std::exception& e) {
58850       {
58851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58852       };
58853     } catch (Dali::DaliException e) {
58854       {
58855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58856       };
58857     } catch (...) {
58858       {
58859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58860       };
58861     }
58862   }
58863
58864   jresult = (int)result;
58865   return jresult;
58866 }
58867
58868
58869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
58870   int jresult ;
58871   int result;
58872
58873   {
58874     try {
58875       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
58876     } catch (std::out_of_range& e) {
58877       {
58878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58879       };
58880     } catch (std::exception& e) {
58881       {
58882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58883       };
58884     } catch (Dali::DaliException e) {
58885       {
58886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58887       };
58888     } catch (...) {
58889       {
58890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58891       };
58892     }
58893   }
58894
58895   jresult = (int)result;
58896   return jresult;
58897 }
58898
58899
58900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
58901   int jresult ;
58902   int result;
58903
58904   {
58905     try {
58906       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
58907     } catch (std::out_of_range& e) {
58908       {
58909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58910       };
58911     } catch (std::exception& e) {
58912       {
58913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58914       };
58915     } catch (Dali::DaliException e) {
58916       {
58917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58918       };
58919     } catch (...) {
58920       {
58921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58922       };
58923     }
58924   }
58925
58926   jresult = (int)result;
58927   return jresult;
58928 }
58929
58930
58931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
58932   int jresult ;
58933   int result;
58934
58935   {
58936     try {
58937       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
58938     } catch (std::out_of_range& e) {
58939       {
58940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58941       };
58942     } catch (std::exception& e) {
58943       {
58944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58945       };
58946     } catch (Dali::DaliException e) {
58947       {
58948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58949       };
58950     } catch (...) {
58951       {
58952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58953       };
58954     }
58955   }
58956
58957   jresult = (int)result;
58958   return jresult;
58959 }
58960
58961
58962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
58963   void * jresult ;
58964   Dali::Toolkit::Control result;
58965
58966   {
58967     try {
58968       result = Dali::Toolkit::Internal::Control::New();
58969     } catch (std::out_of_range& e) {
58970       {
58971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58972       };
58973     } catch (std::exception& e) {
58974       {
58975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58976       };
58977     } catch (Dali::DaliException e) {
58978       {
58979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58980       };
58981     } catch (...) {
58982       {
58983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58984       };
58985     }
58986   }
58987
58988   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
58989   return jresult;
58990 }
58991
58992
58993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
58994   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58995   std::string *arg2 = 0 ;
58996
58997   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58998   if (!jarg2) {
58999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59000     return ;
59001   }
59002   std::string arg2_str(jarg2);
59003   arg2 = &arg2_str;
59004   {
59005     try {
59006       (arg1)->SetStyleName((std::string const &)*arg2);
59007     } catch (std::out_of_range& e) {
59008       {
59009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59010       };
59011     } catch (std::exception& e) {
59012       {
59013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59014       };
59015     } catch (Dali::DaliException e) {
59016       {
59017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59018       };
59019     } catch (...) {
59020       {
59021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59022       };
59023     }
59024   }
59025
59026
59027   //argout typemap for const std::string&
59028
59029 }
59030
59031
59032 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
59033   char * jresult ;
59034   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59035   std::string *result = 0 ;
59036
59037   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59038   {
59039     try {
59040       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
59041     } catch (std::out_of_range& e) {
59042       {
59043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59044       };
59045     } catch (std::exception& e) {
59046       {
59047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59048       };
59049     } catch (Dali::DaliException e) {
59050       {
59051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59052       };
59053     } catch (...) {
59054       {
59055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59056       };
59057     }
59058   }
59059
59060   jresult = SWIG_csharp_string_callback(result->c_str());
59061   return jresult;
59062 }
59063
59064
59065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
59066   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59067   Dali::Vector4 *arg2 = 0 ;
59068
59069   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59070   arg2 = (Dali::Vector4 *)jarg2;
59071   if (!arg2) {
59072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
59073     return ;
59074   }
59075   {
59076     try {
59077       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
59078     } catch (std::out_of_range& e) {
59079       {
59080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59081       };
59082     } catch (std::exception& e) {
59083       {
59084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59085       };
59086     } catch (Dali::DaliException e) {
59087       {
59088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59089       };
59090     } catch (...) {
59091       {
59092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59093       };
59094     }
59095   }
59096
59097 }
59098
59099
59100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
59101   void * jresult ;
59102   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
59103   Dali::Vector4 result;
59104
59105   arg1 = (Dali::Handle *)jarg1;
59106   {
59107     try {
59108       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
59109       if (resultMap)
59110       {
59111         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
59112         if(type && type->Get<int>() == Visual::COLOR )
59113         {
59114           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
59115           if (value)
59116           {
59117             result = value->Get<Vector4>();
59118           }
59119         }
59120       }
59121     } catch (std::out_of_range& e) {
59122       {
59123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59124       };
59125     } catch (std::exception& e) {
59126       {
59127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59128       };
59129     } catch (Dali::DaliException e) {
59130       {
59131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59132       };
59133     } catch (...) {
59134       {
59135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59136       };
59137     }
59138   }
59139
59140   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
59141   return jresult;
59142 }
59143
59144
59145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
59146   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59147   Dali::Property::Map *arg2 = 0 ;
59148
59149   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59150   arg2 = (Dali::Property::Map *)jarg2;
59151   if (!arg2) {
59152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59153     return ;
59154   }
59155   {
59156     try {
59157       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
59158     } catch (std::out_of_range& e) {
59159       {
59160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59161       };
59162     } catch (std::exception& e) {
59163       {
59164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59165       };
59166     } catch (Dali::DaliException e) {
59167       {
59168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59169       };
59170     } catch (...) {
59171       {
59172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59173       };
59174     }
59175   }
59176
59177 }
59178
59179
59180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
59181   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59182
59183   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59184   {
59185     try {
59186       (arg1)->ClearBackground();
59187     } catch (std::out_of_range& e) {
59188       {
59189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59190       };
59191     } catch (std::exception& e) {
59192       {
59193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59194       };
59195     } catch (Dali::DaliException e) {
59196       {
59197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59198       };
59199     } catch (...) {
59200       {
59201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59202       };
59203     }
59204   }
59205
59206 }
59207
59208
59209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
59210   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59211   Dali::Gesture::Type arg2 ;
59212
59213   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59214   arg2 = (Dali::Gesture::Type)jarg2;
59215   {
59216     try {
59217       (arg1)->EnableGestureDetection(arg2);
59218     } catch (std::out_of_range& e) {
59219       {
59220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59221       };
59222     } catch (std::exception& e) {
59223       {
59224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59225       };
59226     } catch (Dali::DaliException e) {
59227       {
59228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59229       };
59230     } catch (...) {
59231       {
59232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59233       };
59234     }
59235   }
59236
59237 }
59238
59239
59240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
59241   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59242   Dali::Gesture::Type arg2 ;
59243
59244   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59245   arg2 = (Dali::Gesture::Type)jarg2;
59246   {
59247     try {
59248       (arg1)->DisableGestureDetection(arg2);
59249     } catch (std::out_of_range& e) {
59250       {
59251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59252       };
59253     } catch (std::exception& e) {
59254       {
59255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59256       };
59257     } catch (Dali::DaliException e) {
59258       {
59259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59260       };
59261     } catch (...) {
59262       {
59263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59264       };
59265     }
59266   }
59267
59268 }
59269
59270
59271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
59272   void * jresult ;
59273   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59274   Dali::PinchGestureDetector result;
59275
59276   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59277   {
59278     try {
59279       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
59280     } catch (std::out_of_range& e) {
59281       {
59282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59283       };
59284     } catch (std::exception& e) {
59285       {
59286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59287       };
59288     } catch (Dali::DaliException e) {
59289       {
59290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59291       };
59292     } catch (...) {
59293       {
59294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59295       };
59296     }
59297   }
59298
59299   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
59300   return jresult;
59301 }
59302
59303
59304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
59305   void * jresult ;
59306   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59307   Dali::PanGestureDetector result;
59308
59309   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59310   {
59311     try {
59312       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
59313     } catch (std::out_of_range& e) {
59314       {
59315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59316       };
59317     } catch (std::exception& e) {
59318       {
59319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59320       };
59321     } catch (Dali::DaliException e) {
59322       {
59323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59324       };
59325     } catch (...) {
59326       {
59327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59328       };
59329     }
59330   }
59331
59332   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59333   return jresult;
59334 }
59335
59336
59337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
59338   void * jresult ;
59339   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59340   Dali::TapGestureDetector result;
59341
59342   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59343   {
59344     try {
59345       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
59346     } catch (std::out_of_range& e) {
59347       {
59348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59349       };
59350     } catch (std::exception& e) {
59351       {
59352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59353       };
59354     } catch (Dali::DaliException e) {
59355       {
59356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59357       };
59358     } catch (...) {
59359       {
59360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59361       };
59362     }
59363   }
59364
59365   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
59366   return jresult;
59367 }
59368
59369
59370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
59371   void * jresult ;
59372   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59373   Dali::LongPressGestureDetector result;
59374
59375   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59376   {
59377     try {
59378       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
59379     } catch (std::out_of_range& e) {
59380       {
59381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59382       };
59383     } catch (std::exception& e) {
59384       {
59385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59386       };
59387     } catch (Dali::DaliException e) {
59388       {
59389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59390       };
59391     } catch (...) {
59392       {
59393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59394       };
59395     }
59396   }
59397
59398   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
59399   return jresult;
59400 }
59401
59402
59403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
59404   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59405   bool arg2 ;
59406
59407   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59408   arg2 = jarg2 ? true : false;
59409   {
59410     try {
59411       (arg1)->SetKeyboardNavigationSupport(arg2);
59412     } catch (std::out_of_range& e) {
59413       {
59414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59415       };
59416     } catch (std::exception& e) {
59417       {
59418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59419       };
59420     } catch (Dali::DaliException e) {
59421       {
59422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59423       };
59424     } catch (...) {
59425       {
59426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59427       };
59428     }
59429   }
59430
59431 }
59432
59433
59434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
59435   unsigned int jresult ;
59436   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59437   bool result;
59438
59439   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59440   {
59441     try {
59442       result = (bool)(arg1)->IsKeyboardNavigationSupported();
59443     } catch (std::out_of_range& e) {
59444       {
59445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59446       };
59447     } catch (std::exception& e) {
59448       {
59449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59450       };
59451     } catch (Dali::DaliException e) {
59452       {
59453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59454       };
59455     } catch (...) {
59456       {
59457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59458       };
59459     }
59460   }
59461
59462   jresult = result;
59463   return jresult;
59464 }
59465
59466
59467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
59468   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59469
59470   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59471   {
59472     try {
59473       (arg1)->SetKeyInputFocus();
59474     } catch (std::out_of_range& e) {
59475       {
59476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59477       };
59478     } catch (std::exception& e) {
59479       {
59480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59481       };
59482     } catch (Dali::DaliException e) {
59483       {
59484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59485       };
59486     } catch (...) {
59487       {
59488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59489       };
59490     }
59491   }
59492
59493 }
59494
59495
59496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
59497   unsigned int jresult ;
59498   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59499   bool result;
59500
59501   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59502   {
59503     try {
59504       result = (bool)(arg1)->HasKeyInputFocus();
59505     } catch (std::out_of_range& e) {
59506       {
59507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59508       };
59509     } catch (std::exception& e) {
59510       {
59511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59512       };
59513     } catch (Dali::DaliException e) {
59514       {
59515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59516       };
59517     } catch (...) {
59518       {
59519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59520       };
59521     }
59522   }
59523
59524   jresult = result;
59525   return jresult;
59526 }
59527
59528
59529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
59530   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59531
59532   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59533   {
59534     try {
59535       (arg1)->ClearKeyInputFocus();
59536     } catch (std::out_of_range& e) {
59537       {
59538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59539       };
59540     } catch (std::exception& e) {
59541       {
59542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59543       };
59544     } catch (Dali::DaliException e) {
59545       {
59546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59547       };
59548     } catch (...) {
59549       {
59550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59551       };
59552     }
59553   }
59554
59555 }
59556
59557
59558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
59559   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59560   bool arg2 ;
59561
59562   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59563   arg2 = jarg2 ? true : false;
59564   {
59565     try {
59566       (arg1)->SetAsKeyboardFocusGroup(arg2);
59567     } catch (std::out_of_range& e) {
59568       {
59569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59570       };
59571     } catch (std::exception& e) {
59572       {
59573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59574       };
59575     } catch (Dali::DaliException e) {
59576       {
59577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59578       };
59579     } catch (...) {
59580       {
59581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59582       };
59583     }
59584   }
59585
59586 }
59587
59588
59589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
59590   unsigned int jresult ;
59591   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59592   bool result;
59593
59594   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59595   {
59596     try {
59597       result = (bool)(arg1)->IsKeyboardFocusGroup();
59598     } catch (std::out_of_range& e) {
59599       {
59600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59601       };
59602     } catch (std::exception& e) {
59603       {
59604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59605       };
59606     } catch (Dali::DaliException e) {
59607       {
59608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59609       };
59610     } catch (...) {
59611       {
59612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59613       };
59614     }
59615   }
59616
59617   jresult = result;
59618   return jresult;
59619 }
59620
59621
59622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
59623   void * jresult ;
59624   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59625   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
59626
59627   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59628   {
59629     try {
59630       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
59631     } catch (std::out_of_range& e) {
59632       {
59633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59634       };
59635     } catch (std::exception& e) {
59636       {
59637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59638       };
59639     } catch (Dali::DaliException e) {
59640       {
59641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59642       };
59643     } catch (...) {
59644       {
59645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59646       };
59647     }
59648   }
59649
59650   jresult = (void *)result;
59651   return jresult;
59652 }
59653
59654
59655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
59656   void * jresult ;
59657   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59658   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59659
59660   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59661   {
59662     try {
59663       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
59664     } catch (std::out_of_range& e) {
59665       {
59666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59667       };
59668     } catch (std::exception& e) {
59669       {
59670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59671       };
59672     } catch (Dali::DaliException e) {
59673       {
59674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59675       };
59676     } catch (...) {
59677       {
59678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59679       };
59680     }
59681   }
59682
59683   jresult = (void *)result;
59684   return jresult;
59685 }
59686
59687
59688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
59689   void * jresult ;
59690   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59691   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59692
59693   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59694   {
59695     try {
59696       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
59697     } catch (std::out_of_range& e) {
59698       {
59699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59700       };
59701     } catch (std::exception& e) {
59702       {
59703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59704       };
59705     } catch (Dali::DaliException e) {
59706       {
59707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59708       };
59709     } catch (...) {
59710       {
59711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59712       };
59713     }
59714   }
59715
59716   jresult = (void *)result;
59717   return jresult;
59718 }
59719
59720
59721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
59722   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59723   int arg2 ;
59724   SwigDirector_ViewImpl *darg = 0;
59725
59726   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59727   arg2 = (int)jarg2;
59728   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59729   if(!darg) {
59730     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59731     return;
59732   }
59733   {
59734     try {
59735       if(darg) {
59736         (darg)->OnSceneConnection(arg2);
59737       }
59738     } catch (std::out_of_range& e) {
59739       {
59740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59741       };
59742     } catch (std::exception& e) {
59743       {
59744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59745       };
59746     } catch (Dali::DaliException e) {
59747       {
59748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59749       };
59750     } catch (...) {
59751       {
59752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59753       };
59754     }
59755   }
59756
59757 }
59758
59759
59760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
59761   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59762   int arg2 ;
59763   SwigDirector_ViewImpl *darg = 0;
59764
59765   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59766   arg2 = (int)jarg2;
59767   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59768   if(!darg) {
59769     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59770     return;
59771   }
59772   {
59773     try {
59774       if(darg) {
59775         (darg)->OnSceneConnectionSwigPublic(arg2);
59776       }
59777     } catch (std::out_of_range& e) {
59778       {
59779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59780       };
59781     } catch (std::exception& e) {
59782       {
59783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59784       };
59785     } catch (Dali::DaliException e) {
59786       {
59787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59788       };
59789     } catch (...) {
59790       {
59791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59792       };
59793     }
59794   }
59795
59796 }
59797
59798
59799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
59800   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59801   SwigDirector_ViewImpl *darg = 0;
59802
59803   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59804   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59805   if(!darg) {
59806     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59807     return;
59808   }
59809   {
59810     try {
59811       if(darg) {
59812         (darg)->OnSceneDisconnection();
59813       }
59814     } catch (std::out_of_range& e) {
59815       {
59816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59817       };
59818     } catch (std::exception& e) {
59819       {
59820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59821       };
59822     } catch (Dali::DaliException e) {
59823       {
59824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59825       };
59826     } catch (...) {
59827       {
59828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59829       };
59830     }
59831   }
59832
59833 }
59834
59835
59836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
59837   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59838   SwigDirector_ViewImpl *darg = 0;
59839
59840   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59841   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59842   if(!darg) {
59843     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59844     return;
59845   }
59846   {
59847     try {
59848       if(darg) {
59849         (darg)->OnSceneDisconnectionSwigPublic();
59850       }
59851     } catch (std::out_of_range& e) {
59852       {
59853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59854       };
59855     } catch (std::exception& e) {
59856       {
59857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59858       };
59859     } catch (Dali::DaliException e) {
59860       {
59861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59862       };
59863     } catch (...) {
59864       {
59865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59866       };
59867     }
59868   }
59869
59870 }
59871
59872
59873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
59874   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59875   Dali::Actor *arg2 = 0 ;
59876   SwigDirector_ViewImpl *darg = 0;
59877
59878   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59879   arg2 = (Dali::Actor *)jarg2;
59880   if (!arg2) {
59881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59882     return ;
59883   }
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)->OnChildAdd(*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_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59917   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59918   Dali::Actor *arg2 = 0 ;
59919   SwigDirector_ViewImpl *darg = 0;
59920
59921   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59922   arg2 = (Dali::Actor *)jarg2;
59923   if (!arg2) {
59924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59925     return ;
59926   }
59927   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59928   if(!darg) {
59929     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59930     return;
59931   }
59932   {
59933     try {
59934       if(darg) {
59935           (darg)->OnChildAddSwigPublic(*arg2);
59936       }
59937     } catch (std::out_of_range& e) {
59938       {
59939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59940       };
59941     } catch (std::exception& e) {
59942       {
59943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59944       };
59945     } catch (Dali::DaliException e) {
59946       {
59947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59948       };
59949     } catch (...) {
59950       {
59951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59952       };
59953     }
59954   }
59955
59956 }
59957
59958
59959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
59960   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59961   Dali::Actor *arg2 = 0 ;
59962   SwigDirector_ViewImpl *darg = 0;
59963
59964   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59965   arg2 = (Dali::Actor *)jarg2;
59966   if (!arg2) {
59967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59968     return ;
59969   }
59970   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59971   if(!darg) {
59972     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59973     return;
59974   }
59975   {
59976     try {
59977       if(darg) {
59978         (darg)->OnChildRemove(*arg2);
59979       }
59980     } catch (std::out_of_range& e) {
59981       {
59982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59983       };
59984     } catch (std::exception& e) {
59985       {
59986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59987       };
59988     } catch (Dali::DaliException e) {
59989       {
59990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59991       };
59992     } catch (...) {
59993       {
59994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59995       };
59996     }
59997   }
59998
59999 }
60000
60001
60002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60003   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60004   Dali::Actor *arg2 = 0 ;
60005   SwigDirector_ViewImpl *darg = 0;
60006
60007   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60008   arg2 = (Dali::Actor *)jarg2;
60009   if (!arg2) {
60010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60011     return ;
60012   }
60013   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60014   if(!darg) {
60015     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60016     return;
60017   }
60018   {
60019     try {
60020       if(darg) {
60021         (darg)->OnChildRemoveSwigPublic(*arg2);
60022       }
60023     } catch (std::out_of_range& e) {
60024       {
60025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60026       };
60027     } catch (std::exception& e) {
60028       {
60029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60030       };
60031     } catch (Dali::DaliException e) {
60032       {
60033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60034       };
60035     } catch (...) {
60036       {
60037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60038       };
60039     }
60040   }
60041
60042 }
60043
60044
60045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
60046   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60047   Dali::Property::Index arg2 ;
60048   Dali::Property::Value arg3 ;
60049   Dali::Property::Value *argp3 ;
60050   SwigDirector_ViewImpl *darg = 0;
60051
60052   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60053   arg2 = (Dali::Property::Index)jarg2;
60054   argp3 = (Dali::Property::Value *)jarg3;
60055   if (!argp3) {
60056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60057     return ;
60058   }
60059   arg3 = *argp3;
60060   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60061   if (!darg) {
60062     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60063     return;
60064   }
60065   {
60066     try {
60067       (darg)->OnPropertySet(arg2,arg3);
60068     } catch (std::out_of_range& e) {
60069       {
60070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60071       };
60072     } catch (std::exception& e) {
60073       {
60074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60075       };
60076     } catch (Dali::DaliException e) {
60077       {
60078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60079       };
60080     } catch (...) {
60081       {
60082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60083       };
60084     }
60085   }
60086
60087 }
60088
60089
60090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
60091   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60092   Dali::Property::Index arg2 ;
60093   Dali::Property::Value arg3 ;
60094   Dali::Property::Value *argp3 ;
60095   SwigDirector_ViewImpl *darg = 0;
60096
60097   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60098   arg2 = (Dali::Property::Index)jarg2;
60099   argp3 = (Dali::Property::Value *)jarg3;
60100   if (!argp3) {
60101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60102     return ;
60103   }
60104   arg3 = *argp3;
60105   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60106   if (!darg) {
60107     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60108     return;
60109   }
60110   {
60111     try {
60112       (darg)->OnPropertySetSwigPublic(arg2,arg3);
60113     } catch (std::out_of_range& e) {
60114       {
60115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60116       };
60117     } catch (std::exception& e) {
60118       {
60119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60120       };
60121     } catch (Dali::DaliException e) {
60122       {
60123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60124       };
60125     } catch (...) {
60126       {
60127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60128       };
60129     }
60130   }
60131
60132 }
60133
60134
60135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
60136   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60137   Dali::Vector3 *arg2 = 0 ;
60138   SwigDirector_ViewImpl *darg = 0;
60139
60140   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60141   arg2 = (Dali::Vector3 *)jarg2;
60142   if (!arg2) {
60143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60144     return ;
60145   }
60146   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60147   if (!darg) {
60148     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60149     return;
60150   }
60151   {
60152     try {
60153       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
60154     } catch (std::out_of_range& e) {
60155       {
60156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60157       };
60158     } catch (std::exception& e) {
60159       {
60160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60161       };
60162     } catch (Dali::DaliException e) {
60163       {
60164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60165       };
60166     } catch (...) {
60167       {
60168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60169       };
60170     }
60171   }
60172
60173 }
60174
60175
60176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60177   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60178   Dali::Vector3 *arg2 = 0 ;
60179   SwigDirector_ViewImpl *darg = 0;
60180
60181   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60182   arg2 = (Dali::Vector3 *)jarg2;
60183   if (!arg2) {
60184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60185     return ;
60186   }
60187   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60188   if (!darg) {
60189     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60190     return;
60191   }
60192   {
60193     try {
60194       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
60195     } catch (std::out_of_range& e) {
60196       {
60197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60198       };
60199     } catch (std::exception& e) {
60200       {
60201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60202       };
60203     } catch (Dali::DaliException e) {
60204       {
60205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60206       };
60207     } catch (...) {
60208       {
60209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60210       };
60211     }
60212   }
60213
60214 }
60215
60216
60217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
60218   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60219   Dali::Animation *arg2 = 0 ;
60220   Dali::Vector3 *arg3 = 0 ;
60221   SwigDirector_ViewImpl *darg = 0;
60222
60223   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60224   arg2 = (Dali::Animation *)jarg2;
60225   if (!arg2) {
60226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60227     return ;
60228   }
60229   arg3 = (Dali::Vector3 *)jarg3;
60230   if (!arg3) {
60231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60232     return ;
60233   }
60234   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60235   if (!darg) {
60236     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60237     return;
60238   }
60239   {
60240     try {
60241       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
60242     } catch (std::out_of_range& e) {
60243       {
60244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60245       };
60246     } catch (std::exception& e) {
60247       {
60248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60249       };
60250     } catch (Dali::DaliException e) {
60251       {
60252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60253       };
60254     } catch (...) {
60255       {
60256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60257       };
60258     }
60259   }
60260
60261 }
60262
60263
60264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60265   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60266   Dali::Animation *arg2 = 0 ;
60267   Dali::Vector3 *arg3 = 0 ;
60268   SwigDirector_ViewImpl *darg = 0;
60269
60270   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60271   arg2 = (Dali::Animation *)jarg2;
60272   if (!arg2) {
60273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60274     return ;
60275   }
60276   arg3 = (Dali::Vector3 *)jarg3;
60277   if (!arg3) {
60278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60279     return ;
60280   }
60281   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60282   if (!darg) {
60283     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60284     return;
60285   }
60286   {
60287     try {
60288       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
60289     } catch (std::out_of_range& e) {
60290       {
60291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60292       };
60293     } catch (std::exception& e) {
60294       {
60295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60296       };
60297     } catch (Dali::DaliException e) {
60298       {
60299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60300       };
60301     } catch (...) {
60302       {
60303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60304       };
60305     }
60306   }
60307 }
60308
60309
60310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
60311   unsigned int jresult ;
60312   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60313   Dali::HoverEvent *arg2 = 0 ;
60314   SwigDirector_ViewImpl *darg = 0;
60315   bool result;
60316
60317   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60318   arg2 = (Dali::HoverEvent *)jarg2;
60319   if (!arg2) {
60320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60321     return 0;
60322   }
60323   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60324   if (!darg) {
60325     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60326     return 0;
60327   }
60328   {
60329     try {
60330       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
60331     } catch (std::out_of_range& e) {
60332       {
60333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60334       };
60335     } catch (std::exception& e) {
60336       {
60337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60338       };
60339     } catch (Dali::DaliException e) {
60340       {
60341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60342       };
60343     } catch (...) {
60344       {
60345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60346       };
60347     }
60348   }
60349
60350   jresult = result;
60351   return jresult;
60352 }
60353
60354
60355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60356   unsigned int jresult ;
60357   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60358   Dali::HoverEvent *arg2 = 0 ;
60359   SwigDirector_ViewImpl *darg = 0;
60360   bool result;
60361
60362   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60363   arg2 = (Dali::HoverEvent *)jarg2;
60364   if (!arg2) {
60365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60366     return 0;
60367   }
60368   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60369   if (!darg) {
60370     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60371     return 0;
60372   }
60373   {
60374     try {
60375       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
60376     } catch (std::out_of_range& e) {
60377       {
60378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60379       };
60380     } catch (std::exception& e) {
60381       {
60382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60383       };
60384     } catch (Dali::DaliException e) {
60385       {
60386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60387       };
60388     } catch (...) {
60389       {
60390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60391       };
60392     }
60393   }
60394
60395   jresult = result;
60396   return jresult;
60397 }
60398
60399
60400 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
60401   unsigned int jresult ;
60402   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60403   Dali::KeyEvent *arg2 = 0 ;
60404   SwigDirector_ViewImpl *darg = 0;
60405   bool result;
60406
60407   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60408   arg2 = (Dali::KeyEvent *)jarg2;
60409   if (!arg2) {
60410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60411     return 0;
60412   }
60413   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60414   if (!darg) {
60415     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60416     return 0;
60417   }
60418   {
60419     try {
60420       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
60421     } catch (std::out_of_range& e) {
60422       {
60423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60424       };
60425     } catch (std::exception& e) {
60426       {
60427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60428       };
60429     } catch (Dali::DaliException e) {
60430       {
60431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60432       };
60433     } catch (...) {
60434       {
60435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60436       };
60437     }
60438   }
60439
60440   jresult = result;
60441   return jresult;
60442 }
60443
60444
60445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60446   unsigned int jresult ;
60447   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60448   Dali::KeyEvent *arg2 = 0 ;
60449   SwigDirector_ViewImpl *darg = 0;
60450   bool result;
60451
60452   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60453   arg2 = (Dali::KeyEvent *)jarg2;
60454   if (!arg2) {
60455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60456     return 0;
60457   }
60458   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60459   if (!darg) {
60460     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60461     return 0;
60462   }
60463   {
60464     try {
60465       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
60466     } catch (std::out_of_range& e) {
60467       {
60468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60469       };
60470     } catch (std::exception& e) {
60471       {
60472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60473       };
60474     } catch (Dali::DaliException e) {
60475       {
60476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60477       };
60478     } catch (...) {
60479       {
60480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60481       };
60482     }
60483   }
60484
60485   jresult = result;
60486   return jresult;
60487 }
60488
60489
60490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
60491   unsigned int jresult ;
60492   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60493   Dali::WheelEvent *arg2 = 0 ;
60494   SwigDirector_ViewImpl *darg = 0;
60495   bool result;
60496
60497   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60498   arg2 = (Dali::WheelEvent *)jarg2;
60499   if (!arg2) {
60500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60501     return 0;
60502   }
60503   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60504   if (!darg) {
60505     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60506     return 0;
60507   }
60508   {
60509     try {
60510       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
60511     } catch (std::out_of_range& e) {
60512       {
60513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60514       };
60515     } catch (std::exception& e) {
60516       {
60517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60518       };
60519     } catch (Dali::DaliException e) {
60520       {
60521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60522       };
60523     } catch (...) {
60524       {
60525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60526       };
60527     }
60528   }
60529
60530   jresult = result;
60531   return jresult;
60532 }
60533
60534
60535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60536   unsigned int jresult ;
60537   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60538   Dali::WheelEvent *arg2 = 0 ;
60539   SwigDirector_ViewImpl *darg = 0;
60540   bool result;
60541
60542   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60543   arg2 = (Dali::WheelEvent *)jarg2;
60544   if (!arg2) {
60545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60546     return 0;
60547   }
60548   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60549   if (!darg) {
60550     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60551     return 0;
60552   }
60553   {
60554     try {
60555       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
60556     } catch (std::out_of_range& e) {
60557       {
60558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60559       };
60560     } catch (std::exception& e) {
60561       {
60562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60563       };
60564     } catch (Dali::DaliException e) {
60565       {
60566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60567       };
60568     } catch (...) {
60569       {
60570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60571       };
60572     }
60573   }
60574
60575   jresult = result;
60576   return jresult;
60577 }
60578
60579
60580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
60581   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60582   Dali::Vector2 *arg2 = 0 ;
60583   Dali::RelayoutContainer *arg3 = 0 ;
60584   SwigDirector_ViewImpl *darg = 0;
60585
60586   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60587   arg2 = (Dali::Vector2 *)jarg2;
60588   if (!arg2) {
60589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60590     return ;
60591   }
60592   arg3 = (Dali::RelayoutContainer *)jarg3;
60593   if (!arg3) {
60594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60595     return ;
60596   }
60597   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60598   if (!darg) {
60599     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60600     return;
60601   }
60602   {
60603     try {
60604       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
60605     } catch (std::out_of_range& e) {
60606       {
60607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60608       };
60609     } catch (std::exception& e) {
60610       {
60611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60612       };
60613     } catch (Dali::DaliException e) {
60614       {
60615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60616       };
60617     } catch (...) {
60618       {
60619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60620       };
60621     }
60622   }
60623
60624 }
60625
60626
60627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60628   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60629   Dali::Vector2 *arg2 = 0 ;
60630   Dali::RelayoutContainer *arg3 = 0 ;
60631   SwigDirector_ViewImpl *darg = 0;
60632
60633   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60634   arg2 = (Dali::Vector2 *)jarg2;
60635   if (!arg2) {
60636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60637     return ;
60638   }
60639   arg3 = (Dali::RelayoutContainer *)jarg3;
60640   if (!arg3) {
60641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60642     return ;
60643   }
60644   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60645   if (!darg) {
60646     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60647     return;
60648   }
60649   {
60650     try {
60651       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
60652     } catch (std::out_of_range& e) {
60653       {
60654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60655       };
60656     } catch (std::exception& e) {
60657       {
60658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60659       };
60660     } catch (Dali::DaliException e) {
60661       {
60662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60663       };
60664     } catch (...) {
60665       {
60666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60667       };
60668     }
60669   }
60670
60671 }
60672
60673
60674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
60675   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60676   Dali::ResizePolicy::Type arg2 ;
60677   Dali::Dimension::Type arg3 ;
60678   SwigDirector_ViewImpl *darg = 0;
60679
60680   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60681   arg2 = (Dali::ResizePolicy::Type)jarg2;
60682   arg3 = (Dali::Dimension::Type)jarg3;
60683   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60684   if (!darg) {
60685     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60686     return;
60687   }
60688   {
60689     try {
60690       (darg)->OnSetResizePolicy(arg2,arg3);
60691     } catch (std::out_of_range& e) {
60692       {
60693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60694       };
60695     } catch (std::exception& e) {
60696       {
60697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60698       };
60699     } catch (Dali::DaliException e) {
60700       {
60701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60702       };
60703     } catch (...) {
60704       {
60705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60706       };
60707     }
60708   }
60709
60710 }
60711
60712
60713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
60714   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60715   Dali::ResizePolicy::Type arg2 ;
60716   Dali::Dimension::Type arg3 ;
60717   SwigDirector_ViewImpl *darg = 0;
60718
60719   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60720   arg2 = (Dali::ResizePolicy::Type)jarg2;
60721   arg3 = (Dali::Dimension::Type)jarg3;
60722   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60723   if (!darg) {
60724     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60725     return;
60726   }
60727   {
60728     try {
60729       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
60730     } catch (std::out_of_range& e) {
60731       {
60732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60733       };
60734     } catch (std::exception& e) {
60735       {
60736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60737       };
60738     } catch (Dali::DaliException e) {
60739       {
60740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60741       };
60742     } catch (...) {
60743       {
60744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60745       };
60746     }
60747   }
60748
60749 }
60750
60751
60752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
60753   void * jresult ;
60754   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60755   SwigDirector_ViewImpl *darg = 0;
60756   Dali::Vector3 result;
60757
60758   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60759   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60760   if (!darg) {
60761     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60762     return 0;
60763   }
60764   {
60765     try {
60766       result = (darg)->GetNaturalSize();
60767     } catch (std::out_of_range& e) {
60768       {
60769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60770       };
60771     } catch (std::exception& e) {
60772       {
60773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60774       };
60775     } catch (Dali::DaliException e) {
60776       {
60777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60778       };
60779     } catch (...) {
60780       {
60781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60782       };
60783     }
60784   }
60785
60786   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60787   return jresult;
60788 }
60789
60790
60791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
60792   void * jresult ;
60793   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60794   SwigDirector_ViewImpl *darg = 0;
60795   Dali::Vector3 result;
60796
60797   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60798   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60799   if (!darg) {
60800     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60801     return 0;
60802   }
60803   {
60804     try {
60805       result = (darg)->GetNaturalSizeSwigPublic();
60806     } catch (std::out_of_range& e) {
60807       {
60808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60809       };
60810     } catch (std::exception& e) {
60811       {
60812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60813       };
60814     } catch (Dali::DaliException e) {
60815       {
60816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60817       };
60818     } catch (...) {
60819       {
60820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60821       };
60822     }
60823   }
60824
60825   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60826   return jresult;
60827 }
60828
60829
60830 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
60831   float jresult ;
60832   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60833   Dali::Actor *arg2 = 0 ;
60834   Dali::Dimension::Type arg3 ;
60835   SwigDirector_ViewImpl *darg = 0;
60836   float result;
60837
60838   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60839   arg2 = (Dali::Actor *)jarg2;
60840   if (!arg2) {
60841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60842     return 0;
60843   }
60844   arg3 = (Dali::Dimension::Type)jarg3;
60845   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60846   if (!darg) {
60847     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60848     return 0;
60849   }
60850   {
60851     try {
60852       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
60853     } catch (std::out_of_range& e) {
60854       {
60855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60856       };
60857     } catch (std::exception& e) {
60858       {
60859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60860       };
60861     } catch (Dali::DaliException e) {
60862       {
60863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60864       };
60865     } catch (...) {
60866       {
60867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60868       };
60869     }
60870   }
60871
60872   jresult = result;
60873   return jresult;
60874 }
60875
60876
60877 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
60878   float jresult ;
60879   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60880   Dali::Actor *arg2 = 0 ;
60881   Dali::Dimension::Type arg3 ;
60882   SwigDirector_ViewImpl *darg = 0;
60883   float result;
60884
60885   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60886   arg2 = (Dali::Actor *)jarg2;
60887   if (!arg2) {
60888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60889     return 0;
60890   }
60891   arg3 = (Dali::Dimension::Type)jarg3;
60892   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60893   if (!darg) {
60894     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60895     return 0;
60896   }
60897   {
60898     try {
60899       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
60900     } catch (std::out_of_range& e) {
60901       {
60902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60903       };
60904     } catch (std::exception& e) {
60905       {
60906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60907       };
60908     } catch (Dali::DaliException e) {
60909       {
60910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60911       };
60912     } catch (...) {
60913       {
60914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60915       };
60916     }
60917   }
60918
60919   jresult = result;
60920   return jresult;
60921 }
60922
60923
60924 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
60925   float jresult ;
60926   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60927   float arg2 ;
60928   SwigDirector_ViewImpl *darg = 0;
60929   float result;
60930
60931   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60932   arg2 = (float)jarg2;
60933   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60934   if (!darg) {
60935     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60936     return 0;
60937   }
60938   {
60939     try {
60940       result = (float)(darg)->GetHeightForWidth(arg2);
60941     } catch (std::out_of_range& e) {
60942       {
60943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60944       };
60945     } catch (std::exception& e) {
60946       {
60947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60948       };
60949     } catch (Dali::DaliException e) {
60950       {
60951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60952       };
60953     } catch (...) {
60954       {
60955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60956       };
60957     }
60958   }
60959
60960   jresult = result;
60961   return jresult;
60962 }
60963
60964
60965 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
60966   float jresult ;
60967   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60968   float arg2 ;
60969   SwigDirector_ViewImpl *darg = 0;
60970   float result;
60971
60972   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60973   arg2 = (float)jarg2;
60974   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60975   if (!darg) {
60976     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60977     return 0;
60978   }
60979   {
60980     try {
60981       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
60982     } catch (std::out_of_range& e) {
60983       {
60984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60985       };
60986     } catch (std::exception& e) {
60987       {
60988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60989       };
60990     } catch (Dali::DaliException e) {
60991       {
60992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60993       };
60994     } catch (...) {
60995       {
60996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60997       };
60998     }
60999   }
61000
61001   jresult = result;
61002   return jresult;
61003 }
61004
61005
61006 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
61007   float jresult ;
61008   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61009   float arg2 ;
61010   SwigDirector_ViewImpl *darg = 0;
61011   float result;
61012
61013   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61014   arg2 = (float)jarg2;
61015   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61016   if (!darg) {
61017     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61018     return 0;
61019   }
61020   {
61021     try {
61022       result = (float)(darg)->GetWidthForHeight(arg2);
61023     } catch (std::out_of_range& e) {
61024       {
61025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61026       };
61027     } catch (std::exception& e) {
61028       {
61029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61030       };
61031     } catch (Dali::DaliException e) {
61032       {
61033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61034       };
61035     } catch (...) {
61036       {
61037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61038       };
61039     }
61040   }
61041
61042   jresult = result;
61043   return jresult;
61044 }
61045
61046
61047 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
61048   float jresult ;
61049   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61050   float arg2 ;
61051   SwigDirector_ViewImpl *darg = 0;
61052   float result;
61053
61054   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61055   arg2 = (float)jarg2;
61056   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61057   if (!darg) {
61058     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61059     return 0;
61060   }
61061   {
61062     try {
61063       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
61064     } catch (std::out_of_range& e) {
61065       {
61066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61067       };
61068     } catch (std::exception& e) {
61069       {
61070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61071       };
61072     } catch (Dali::DaliException e) {
61073       {
61074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61075       };
61076     } catch (...) {
61077       {
61078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61079       };
61080     }
61081   }
61082
61083   jresult = result;
61084   return jresult;
61085 }
61086
61087
61088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
61089   unsigned int jresult ;
61090   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61091   Dali::Dimension::Type arg2 ;
61092   SwigDirector_ViewImpl *darg = 0;
61093   bool result;
61094
61095   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61096   arg2 = (Dali::Dimension::Type)jarg2;
61097   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61098   if (!darg) {
61099     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61100     return 0;
61101   }
61102   {
61103     try {
61104       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
61105     } catch (std::out_of_range& e) {
61106       {
61107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61108       };
61109     } catch (std::exception& e) {
61110       {
61111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61112       };
61113     } catch (Dali::DaliException e) {
61114       {
61115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61116       };
61117     } catch (...) {
61118       {
61119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61120       };
61121     }
61122   }
61123
61124   jresult = result;
61125   return jresult;
61126 }
61127
61128
61129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61130   unsigned int jresult ;
61131   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61132   Dali::Dimension::Type arg2 ;
61133   SwigDirector_ViewImpl *darg = 0;
61134   bool result;
61135
61136   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61137   arg2 = (Dali::Dimension::Type)jarg2;
61138   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61139   if (!darg) {
61140     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61141     return 0;
61142   }
61143   {
61144     try {
61145       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61146     } catch (std::out_of_range& e) {
61147       {
61148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61149       };
61150     } catch (std::exception& e) {
61151       {
61152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61153       };
61154     } catch (Dali::DaliException e) {
61155       {
61156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61157       };
61158     } catch (...) {
61159       {
61160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61161       };
61162     }
61163   }
61164
61165   jresult = result;
61166   return jresult;
61167 }
61168
61169
61170 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61171   unsigned int jresult ;
61172   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61173   SwigDirector_ViewImpl *darg = 0;
61174   bool result;
61175
61176   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61177   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61178   if (!darg) {
61179     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61180     return 0;
61181   }
61182   {
61183     try {
61184       result = (bool)(darg)->RelayoutDependentOnChildren();
61185     } catch (std::out_of_range& e) {
61186       {
61187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61188       };
61189     } catch (std::exception& e) {
61190       {
61191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61192       };
61193     } catch (Dali::DaliException e) {
61194       {
61195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61196       };
61197     } catch (...) {
61198       {
61199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61200       };
61201     }
61202   }
61203
61204   jresult = result;
61205   return jresult;
61206 }
61207
61208
61209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
61210   unsigned int jresult ;
61211   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61212   SwigDirector_ViewImpl *darg = 0;
61213   bool result;
61214
61215   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61216   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61217   if (!darg) {
61218     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61219     return 0;
61220   }
61221   {
61222     try {
61223       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
61224     } catch (std::out_of_range& e) {
61225       {
61226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61227       };
61228     } catch (std::exception& e) {
61229       {
61230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61231       };
61232     } catch (Dali::DaliException e) {
61233       {
61234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61235       };
61236     } catch (...) {
61237       {
61238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61239       };
61240     }
61241   }
61242
61243   jresult = result;
61244   return jresult;
61245 }
61246
61247
61248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
61249   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61250   Dali::Dimension::Type arg2 ;
61251   SwigDirector_ViewImpl *darg = 0;
61252
61253   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61254   arg2 = (Dali::Dimension::Type)jarg2;
61255   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61256   if (!darg) {
61257     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61258     return;
61259   }
61260   {
61261     try {
61262       (darg)->OnCalculateRelayoutSize(arg2);
61263     } catch (std::out_of_range& e) {
61264       {
61265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61266       };
61267     } catch (std::exception& e) {
61268       {
61269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61270       };
61271     } catch (Dali::DaliException e) {
61272       {
61273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61274       };
61275     } catch (...) {
61276       {
61277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61278       };
61279     }
61280   }
61281
61282 }
61283
61284
61285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
61286   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61287   Dali::Dimension::Type arg2 ;
61288   SwigDirector_ViewImpl *darg = 0;
61289
61290   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61291   arg2 = (Dali::Dimension::Type)jarg2;
61292   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61293   if (!darg) {
61294     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61295     return;
61296   }
61297   {
61298     try {
61299       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
61300     } catch (std::out_of_range& e) {
61301       {
61302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61303       };
61304     } catch (std::exception& e) {
61305       {
61306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61307       };
61308     } catch (Dali::DaliException e) {
61309       {
61310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61311       };
61312     } catch (...) {
61313       {
61314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61315       };
61316     }
61317   }
61318
61319 }
61320
61321
61322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
61323   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61324   float arg2 ;
61325   Dali::Dimension::Type arg3 ;
61326   SwigDirector_ViewImpl *darg = 0;
61327
61328   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61329   arg2 = (float)jarg2;
61330   arg3 = (Dali::Dimension::Type)jarg3;
61331   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61332   if (!darg) {
61333     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61334     return;
61335   }
61336   {
61337     try {
61338       (darg)->OnLayoutNegotiated(arg2,arg3);
61339     } catch (std::out_of_range& e) {
61340       {
61341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61342       };
61343     } catch (std::exception& e) {
61344       {
61345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61346       };
61347     } catch (Dali::DaliException e) {
61348       {
61349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61350       };
61351     } catch (...) {
61352       {
61353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61354       };
61355     }
61356   }
61357
61358 }
61359
61360
61361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
61362   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61363   float arg2 ;
61364   Dali::Dimension::Type arg3 ;
61365   SwigDirector_ViewImpl *darg = 0;
61366
61367   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61368   arg2 = (float)jarg2;
61369   arg3 = (Dali::Dimension::Type)jarg3;
61370   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61371   if (!darg) {
61372     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61373     return;
61374   }
61375   {
61376     try {
61377       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
61378     } catch (std::out_of_range& e) {
61379       {
61380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61381       };
61382     } catch (std::exception& e) {
61383       {
61384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61385       };
61386     } catch (Dali::DaliException e) {
61387       {
61388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61389       };
61390     } catch (...) {
61391       {
61392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61393       };
61394     }
61395   }
61396
61397 }
61398
61399
61400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
61401   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61402
61403   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61404   {
61405     try {
61406       (arg1)->OnInitialize();
61407     } catch (std::out_of_range& e) {
61408       {
61409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61410       };
61411     } catch (std::exception& e) {
61412       {
61413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61414       };
61415     } catch (Dali::DaliException e) {
61416       {
61417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61418       };
61419     } catch (...) {
61420       {
61421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61422       };
61423     }
61424   }
61425
61426 }
61427
61428
61429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
61430   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61431
61432   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61433   {
61434     try {
61435       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
61436     } catch (std::out_of_range& e) {
61437       {
61438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61439       };
61440     } catch (std::exception& e) {
61441       {
61442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61443       };
61444     } catch (Dali::DaliException e) {
61445       {
61446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61447       };
61448     } catch (...) {
61449       {
61450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61451       };
61452     }
61453   }
61454
61455 }
61456
61457
61458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
61459   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61460   Dali::Toolkit::StyleManager arg2 ;
61461   Dali::StyleChange::Type arg3 ;
61462   Dali::Toolkit::StyleManager *argp2 ;
61463
61464   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61465   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61466   if (!argp2) {
61467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61468     return ;
61469   }
61470   arg2 = *argp2;
61471   arg3 = (Dali::StyleChange::Type)jarg3;
61472   {
61473     try {
61474       (arg1)->OnStyleChange(arg2,arg3);
61475     } catch (std::out_of_range& e) {
61476       {
61477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61478       };
61479     } catch (std::exception& e) {
61480       {
61481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61482       };
61483     } catch (Dali::DaliException e) {
61484       {
61485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61486       };
61487     } catch (...) {
61488       {
61489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61490       };
61491     }
61492   }
61493
61494 }
61495
61496
61497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61498   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61499   Dali::Toolkit::StyleManager arg2 ;
61500   Dali::StyleChange::Type arg3 ;
61501   Dali::Toolkit::StyleManager *argp2 ;
61502
61503   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61504   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61505   if (!argp2) {
61506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61507     return ;
61508   }
61509   arg2 = *argp2;
61510   arg3 = (Dali::StyleChange::Type)jarg3;
61511   {
61512     try {
61513       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
61514     } catch (std::out_of_range& e) {
61515       {
61516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61517       };
61518     } catch (std::exception& e) {
61519       {
61520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61521       };
61522     } catch (Dali::DaliException e) {
61523       {
61524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61525       };
61526     } catch (...) {
61527       {
61528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61529       };
61530     }
61531   }
61532
61533 }
61534
61535
61536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
61537   unsigned int jresult ;
61538   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61539   bool result;
61540
61541   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61542   {
61543     try {
61544       result = (bool)(arg1)->OnAccessibilityActivated();
61545     } catch (std::out_of_range& e) {
61546       {
61547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61548       };
61549     } catch (std::exception& e) {
61550       {
61551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61552       };
61553     } catch (Dali::DaliException e) {
61554       {
61555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61556       };
61557     } catch (...) {
61558       {
61559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61560       };
61561     }
61562   }
61563
61564   jresult = result;
61565   return jresult;
61566 }
61567
61568
61569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
61570   unsigned int jresult ;
61571   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61572   bool result;
61573
61574   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61575   {
61576     try {
61577       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
61578     } catch (std::out_of_range& e) {
61579       {
61580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61581       };
61582     } catch (std::exception& e) {
61583       {
61584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61585       };
61586     } catch (Dali::DaliException e) {
61587       {
61588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61589       };
61590     } catch (...) {
61591       {
61592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61593       };
61594     }
61595   }
61596
61597   jresult = result;
61598   return jresult;
61599 }
61600
61601
61602 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
61603   unsigned int jresult ;
61604   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61605   Dali::PanGesture arg2 ;
61606   Dali::PanGesture *argp2 ;
61607   bool result;
61608
61609   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61610   argp2 = (Dali::PanGesture *)jarg2;
61611   if (!argp2) {
61612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61613     return 0;
61614   }
61615   arg2 = *argp2;
61616   {
61617     try {
61618       result = (bool)(arg1)->OnAccessibilityPan(arg2);
61619     } catch (std::out_of_range& e) {
61620       {
61621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61622       };
61623     } catch (std::exception& e) {
61624       {
61625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61626       };
61627     } catch (Dali::DaliException e) {
61628       {
61629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61630       };
61631     } catch (...) {
61632       {
61633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61634       };
61635     }
61636   }
61637
61638   jresult = result;
61639   return jresult;
61640 }
61641
61642
61643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61644   unsigned int jresult ;
61645   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61646   Dali::PanGesture arg2 ;
61647   Dali::PanGesture *argp2 ;
61648   bool result;
61649
61650   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61651   argp2 = (Dali::PanGesture *)jarg2;
61652   if (!argp2) {
61653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61654     return 0;
61655   }
61656   arg2 = *argp2;
61657   {
61658     try {
61659       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
61660     } catch (std::out_of_range& e) {
61661       {
61662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61663       };
61664     } catch (std::exception& e) {
61665       {
61666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61667       };
61668     } catch (Dali::DaliException e) {
61669       {
61670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61671       };
61672     } catch (...) {
61673       {
61674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61675       };
61676     }
61677   }
61678
61679   jresult = result;
61680   return jresult;
61681 }
61682
61683
61684 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
61685   unsigned int jresult ;
61686   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61687   Dali::TouchData *arg2 = 0 ;
61688   bool result;
61689
61690   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61691   arg2 = (Dali::TouchData *)jarg2;
61692   if (!arg2) {
61693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
61694     return 0;
61695   }
61696   {
61697     try {
61698       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchData const &)*arg2);
61699     } catch (std::out_of_range& e) {
61700       {
61701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61702       };
61703     } catch (std::exception& e) {
61704       {
61705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61706       };
61707     } catch (Dali::DaliException e) {
61708       {
61709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61710       };
61711     } catch (...) {
61712       {
61713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61714       };
61715     }
61716   }
61717
61718   jresult = result;
61719   return jresult;
61720 }
61721
61722
61723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61724   unsigned int jresult ;
61725   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61726   Dali::TouchData *arg2 = 0 ;
61727   bool result;
61728
61729   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61730   arg2 = (Dali::TouchData *)jarg2;
61731   if (!arg2) {
61732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
61733     return 0;
61734   }
61735   {
61736     try {
61737       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchData const &)*arg2);
61738     } catch (std::out_of_range& e) {
61739       {
61740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61741       };
61742     } catch (std::exception& e) {
61743       {
61744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61745       };
61746     } catch (Dali::DaliException e) {
61747       {
61748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61749       };
61750     } catch (...) {
61751       {
61752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61753       };
61754     }
61755   }
61756
61757   jresult = result;
61758   return jresult;
61759 }
61760
61761
61762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
61763   unsigned int jresult ;
61764   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61765   bool arg2 ;
61766   bool result;
61767
61768   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61769   arg2 = jarg2 ? true : false;
61770   {
61771     try {
61772       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
61773     } catch (std::out_of_range& e) {
61774       {
61775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61776       };
61777     } catch (std::exception& e) {
61778       {
61779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61780       };
61781     } catch (Dali::DaliException e) {
61782       {
61783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61784       };
61785     } catch (...) {
61786       {
61787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61788       };
61789     }
61790   }
61791
61792   jresult = result;
61793   return jresult;
61794 }
61795
61796
61797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
61798   unsigned int jresult ;
61799   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61800   bool arg2 ;
61801   bool result;
61802
61803   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61804   arg2 = jarg2 ? true : false;
61805   {
61806     try {
61807       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
61808     } catch (std::out_of_range& e) {
61809       {
61810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61811       };
61812     } catch (std::exception& e) {
61813       {
61814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61815       };
61816     } catch (Dali::DaliException e) {
61817       {
61818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61819       };
61820     } catch (...) {
61821       {
61822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61823       };
61824     }
61825   }
61826
61827   jresult = result;
61828   return jresult;
61829 }
61830
61831
61832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
61833   unsigned int jresult ;
61834   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61835   bool result;
61836
61837   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61838   {
61839     try {
61840       result = (bool)(arg1)->OnAccessibilityZoom();
61841     } catch (std::out_of_range& e) {
61842       {
61843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61844       };
61845     } catch (std::exception& e) {
61846       {
61847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61848       };
61849     } catch (Dali::DaliException e) {
61850       {
61851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61852       };
61853     } catch (...) {
61854       {
61855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61856       };
61857     }
61858   }
61859
61860   jresult = result;
61861   return jresult;
61862 }
61863
61864
61865 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
61866   unsigned int jresult ;
61867   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61868   bool result;
61869
61870   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61871   {
61872     try {
61873       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
61874     } catch (std::out_of_range& e) {
61875       {
61876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61877       };
61878     } catch (std::exception& e) {
61879       {
61880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61881       };
61882     } catch (Dali::DaliException e) {
61883       {
61884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61885       };
61886     } catch (...) {
61887       {
61888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61889       };
61890     }
61891   }
61892
61893   jresult = result;
61894   return jresult;
61895 }
61896
61897
61898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
61899   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61900
61901   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61902   {
61903     try {
61904       (arg1)->OnKeyInputFocusGained();
61905     } catch (std::out_of_range& e) {
61906       {
61907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61908       };
61909     } catch (std::exception& e) {
61910       {
61911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61912       };
61913     } catch (Dali::DaliException e) {
61914       {
61915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61916       };
61917     } catch (...) {
61918       {
61919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61920       };
61921     }
61922   }
61923
61924 }
61925
61926
61927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
61928   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61929
61930   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61931   {
61932     try {
61933       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
61934     } catch (std::out_of_range& e) {
61935       {
61936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61937       };
61938     } catch (std::exception& e) {
61939       {
61940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61941       };
61942     } catch (Dali::DaliException e) {
61943       {
61944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61945       };
61946     } catch (...) {
61947       {
61948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61949       };
61950     }
61951   }
61952
61953 }
61954
61955
61956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
61957   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61958
61959   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61960   {
61961     try {
61962       (arg1)->OnKeyInputFocusLost();
61963     } catch (std::out_of_range& e) {
61964       {
61965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61966       };
61967     } catch (std::exception& e) {
61968       {
61969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61970       };
61971     } catch (Dali::DaliException e) {
61972       {
61973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61974       };
61975     } catch (...) {
61976       {
61977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61978       };
61979     }
61980   }
61981
61982 }
61983
61984
61985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
61986   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61987
61988   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61989   {
61990     try {
61991       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
61992     } catch (std::out_of_range& e) {
61993       {
61994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61995       };
61996     } catch (std::exception& e) {
61997       {
61998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61999       };
62000     } catch (Dali::DaliException e) {
62001       {
62002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62003       };
62004     } catch (...) {
62005       {
62006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62007       };
62008     }
62009   }
62010
62011 }
62012
62013
62014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62015   void * jresult ;
62016   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62017   Dali::Actor arg2 ;
62018   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62019   bool arg4 ;
62020   Dali::Actor *argp2 ;
62021   Dali::Actor result;
62022
62023   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62024   argp2 = (Dali::Actor *)jarg2;
62025   if (!argp2) {
62026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62027     return 0;
62028   }
62029   arg2 = *argp2;
62030   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62031   arg4 = jarg4 ? true : false;
62032   {
62033     try {
62034       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62035     } catch (std::out_of_range& e) {
62036       {
62037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62038       };
62039     } catch (std::exception& e) {
62040       {
62041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62042       };
62043     } catch (Dali::DaliException e) {
62044       {
62045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62046       };
62047     } catch (...) {
62048       {
62049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62050       };
62051     }
62052   }
62053
62054   jresult = new Dali::Actor((const Dali::Actor &)result);
62055   return jresult;
62056 }
62057
62058
62059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62060   void * jresult ;
62061   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62062   Dali::Actor arg2 ;
62063   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62064   bool arg4 ;
62065   Dali::Actor *argp2 ;
62066   Dali::Actor result;
62067
62068   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62069   argp2 = (Dali::Actor *)jarg2;
62070   if (!argp2) {
62071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62072     return 0;
62073   }
62074   arg2 = *argp2;
62075   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62076   arg4 = jarg4 ? true : false;
62077   {
62078     try {
62079       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62080     } catch (std::out_of_range& e) {
62081       {
62082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62083       };
62084     } catch (std::exception& e) {
62085       {
62086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62087       };
62088     } catch (Dali::DaliException e) {
62089       {
62090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62091       };
62092     } catch (...) {
62093       {
62094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62095       };
62096     }
62097   }
62098
62099   jresult = new Dali::Actor((const Dali::Actor &)result);
62100   return jresult;
62101 }
62102
62103
62104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
62105   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62106   Dali::Actor arg2 ;
62107   Dali::Actor *argp2 ;
62108
62109   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62110   argp2 = (Dali::Actor *)jarg2;
62111   if (!argp2) {
62112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62113     return ;
62114   }
62115   arg2 = *argp2;
62116   {
62117     try {
62118       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
62119     } catch (std::out_of_range& e) {
62120       {
62121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62122       };
62123     } catch (std::exception& e) {
62124       {
62125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62126       };
62127     } catch (Dali::DaliException e) {
62128       {
62129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62130       };
62131     } catch (...) {
62132       {
62133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62134       };
62135     }
62136   }
62137
62138 }
62139
62140
62141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62142   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62143   Dali::Actor arg2 ;
62144   Dali::Actor *argp2 ;
62145
62146   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62147   argp2 = (Dali::Actor *)jarg2;
62148   if (!argp2) {
62149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62150     return ;
62151   }
62152   arg2 = *argp2;
62153   {
62154     try {
62155       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
62156     } catch (std::out_of_range& e) {
62157       {
62158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62159       };
62160     } catch (std::exception& e) {
62161       {
62162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62163       };
62164     } catch (Dali::DaliException e) {
62165       {
62166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62167       };
62168     } catch (...) {
62169       {
62170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62171       };
62172     }
62173   }
62174
62175 }
62176
62177
62178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
62179   unsigned int jresult ;
62180   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62181   bool result;
62182
62183   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62184   {
62185     try {
62186       result = (bool)(arg1)->OnKeyboardEnter();
62187     } catch (std::out_of_range& e) {
62188       {
62189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62190       };
62191     } catch (std::exception& e) {
62192       {
62193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62194       };
62195     } catch (Dali::DaliException e) {
62196       {
62197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62198       };
62199     } catch (...) {
62200       {
62201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62202       };
62203     }
62204   }
62205
62206   jresult = result;
62207   return jresult;
62208 }
62209
62210
62211 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
62212   unsigned int jresult ;
62213   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62214   bool result;
62215
62216   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62217   {
62218     try {
62219       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
62220     } catch (std::out_of_range& e) {
62221       {
62222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62223       };
62224     } catch (std::exception& e) {
62225       {
62226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62227       };
62228     } catch (Dali::DaliException e) {
62229       {
62230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62231       };
62232     } catch (...) {
62233       {
62234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62235       };
62236     }
62237   }
62238
62239   jresult = result;
62240   return jresult;
62241 }
62242
62243
62244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
62245   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62246   Dali::PinchGesture *arg2 = 0 ;
62247
62248   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62249   arg2 = (Dali::PinchGesture *)jarg2;
62250   if (!arg2) {
62251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62252     return ;
62253   }
62254   {
62255     try {
62256       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
62257     } catch (std::out_of_range& e) {
62258       {
62259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62260       };
62261     } catch (std::exception& e) {
62262       {
62263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62264       };
62265     } catch (Dali::DaliException e) {
62266       {
62267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62268       };
62269     } catch (...) {
62270       {
62271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62272       };
62273     }
62274   }
62275
62276 }
62277
62278
62279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62280   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62281   Dali::PinchGesture *arg2 = 0 ;
62282
62283   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62284   arg2 = (Dali::PinchGesture *)jarg2;
62285   if (!arg2) {
62286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62287     return ;
62288   }
62289   {
62290     try {
62291       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
62292     } catch (std::out_of_range& e) {
62293       {
62294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62295       };
62296     } catch (std::exception& e) {
62297       {
62298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62299       };
62300     } catch (Dali::DaliException e) {
62301       {
62302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62303       };
62304     } catch (...) {
62305       {
62306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62307       };
62308     }
62309   }
62310
62311 }
62312
62313
62314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
62315   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62316   Dali::PanGesture *arg2 = 0 ;
62317
62318   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62319   arg2 = (Dali::PanGesture *)jarg2;
62320   if (!arg2) {
62321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62322     return ;
62323   }
62324   {
62325     try {
62326       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
62327     } catch (std::out_of_range& e) {
62328       {
62329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62330       };
62331     } catch (std::exception& e) {
62332       {
62333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62334       };
62335     } catch (Dali::DaliException e) {
62336       {
62337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62338       };
62339     } catch (...) {
62340       {
62341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62342       };
62343     }
62344   }
62345
62346 }
62347
62348
62349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62350   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62351   Dali::PanGesture *arg2 = 0 ;
62352
62353   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62354   arg2 = (Dali::PanGesture *)jarg2;
62355   if (!arg2) {
62356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62357     return ;
62358   }
62359   {
62360     try {
62361       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
62362     } catch (std::out_of_range& e) {
62363       {
62364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62365       };
62366     } catch (std::exception& e) {
62367       {
62368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62369       };
62370     } catch (Dali::DaliException e) {
62371       {
62372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62373       };
62374     } catch (...) {
62375       {
62376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62377       };
62378     }
62379   }
62380
62381 }
62382
62383
62384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
62385   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62386   Dali::TapGesture *arg2 = 0 ;
62387
62388   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62389   arg2 = (Dali::TapGesture *)jarg2;
62390   if (!arg2) {
62391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62392     return ;
62393   }
62394   {
62395     try {
62396       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
62397     } catch (std::out_of_range& e) {
62398       {
62399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62400       };
62401     } catch (std::exception& e) {
62402       {
62403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62404       };
62405     } catch (Dali::DaliException e) {
62406       {
62407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62408       };
62409     } catch (...) {
62410       {
62411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62412       };
62413     }
62414   }
62415
62416 }
62417
62418
62419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62420   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62421   Dali::TapGesture *arg2 = 0 ;
62422
62423   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62424   arg2 = (Dali::TapGesture *)jarg2;
62425   if (!arg2) {
62426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62427     return ;
62428   }
62429   {
62430     try {
62431       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
62432     } catch (std::out_of_range& e) {
62433       {
62434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62435       };
62436     } catch (std::exception& e) {
62437       {
62438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62439       };
62440     } catch (Dali::DaliException e) {
62441       {
62442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62443       };
62444     } catch (...) {
62445       {
62446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62447       };
62448     }
62449   }
62450
62451 }
62452
62453
62454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
62455   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62456   Dali::LongPressGesture *arg2 = 0 ;
62457
62458   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62459   arg2 = (Dali::LongPressGesture *)jarg2;
62460   if (!arg2) {
62461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62462     return ;
62463   }
62464   {
62465     try {
62466       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
62467     } catch (std::out_of_range& e) {
62468       {
62469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62470       };
62471     } catch (std::exception& e) {
62472       {
62473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62474       };
62475     } catch (Dali::DaliException e) {
62476       {
62477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62478       };
62479     } catch (...) {
62480       {
62481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62482       };
62483     }
62484   }
62485
62486 }
62487
62488
62489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62490   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62491   Dali::LongPressGesture *arg2 = 0 ;
62492
62493   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62494   arg2 = (Dali::LongPressGesture *)jarg2;
62495   if (!arg2) {
62496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62497     return ;
62498   }
62499   {
62500     try {
62501       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
62502     } catch (std::out_of_range& e) {
62503       {
62504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62505       };
62506     } catch (std::exception& e) {
62507       {
62508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62509       };
62510     } catch (Dali::DaliException e) {
62511       {
62512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62513       };
62514     } catch (...) {
62515       {
62516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62517       };
62518     }
62519   }
62520
62521 }
62522
62523
62524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
62525   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62526   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62527   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62528
62529   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62530   arg2 = (Dali::SlotObserver *)jarg2;
62531   arg3 = (Dali::CallbackBase *)jarg3;
62532   {
62533     try {
62534       (arg1)->SignalConnected(arg2,arg3);
62535     } catch (std::out_of_range& e) {
62536       {
62537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62538       };
62539     } catch (std::exception& e) {
62540       {
62541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62542       };
62543     } catch (Dali::DaliException e) {
62544       {
62545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62546       };
62547     } catch (...) {
62548       {
62549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62550       };
62551     }
62552   }
62553
62554 }
62555
62556
62557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62558   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62559   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62560   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62561
62562   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62563   arg2 = (Dali::SlotObserver *)jarg2;
62564   arg3 = (Dali::CallbackBase *)jarg3;
62565   {
62566     try {
62567       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
62568     } catch (std::out_of_range& e) {
62569       {
62570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62571       };
62572     } catch (std::exception& e) {
62573       {
62574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62575       };
62576     } catch (Dali::DaliException e) {
62577       {
62578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62579       };
62580     } catch (...) {
62581       {
62582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62583       };
62584     }
62585   }
62586
62587 }
62588
62589
62590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
62591   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62592   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62593   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62594
62595   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62596   arg2 = (Dali::SlotObserver *)jarg2;
62597   arg3 = (Dali::CallbackBase *)jarg3;
62598   {
62599     try {
62600       (arg1)->SignalDisconnected(arg2,arg3);
62601     } catch (std::out_of_range& e) {
62602       {
62603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62604       };
62605     } catch (std::exception& e) {
62606       {
62607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62608       };
62609     } catch (Dali::DaliException e) {
62610       {
62611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62612       };
62613     } catch (...) {
62614       {
62615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62616       };
62617     }
62618   }
62619
62620 }
62621
62622
62623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62624   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62625   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62626   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62627
62628   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62629   arg2 = (Dali::SlotObserver *)jarg2;
62630   arg3 = (Dali::CallbackBase *)jarg3;
62631   {
62632     try {
62633       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
62634     } catch (std::out_of_range& e) {
62635       {
62636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62637       };
62638     } catch (std::exception& e) {
62639       {
62640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62641       };
62642     } catch (Dali::DaliException e) {
62643       {
62644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62645       };
62646     } catch (...) {
62647       {
62648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62649       };
62650     }
62651   }
62652
62653 }
62654
62655 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_Callback27_t callback27, SwigDirector_ViewImpl::SWIG_Callback28_t callback28, SwigDirector_ViewImpl::SWIG_Callback29_t callback29, SwigDirector_ViewImpl::SWIG_Callback30_t callback30, SwigDirector_ViewImpl::SWIG_Callback31_t callback31, SwigDirector_ViewImpl::SWIG_Callback32_t callback32, SwigDirector_ViewImpl::SWIG_Callback33_t callback33, SwigDirector_ViewImpl::SWIG_Callback34_t callback34, SwigDirector_ViewImpl::SWIG_Callback35_t callback35, SwigDirector_ViewImpl::SWIG_Callback36_t callback36, SwigDirector_ViewImpl::SWIG_Callback37_t callback37, SwigDirector_ViewImpl::SWIG_Callback38_t callback38, SwigDirector_ViewImpl::SWIG_Callback39_t callback39, SwigDirector_ViewImpl::SWIG_Callback40_t callback40) {
62656   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
62657   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
62658   if (director) {
62659     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, callback27, callback28, callback29, callback30, callback31, callback32, callback33, callback34, callback35, callback36, callback37, callback38, callback39, callback40);
62660   }
62661 }
62662
62663
62664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
62665   void * jresult ;
62666   Dali::Toolkit::Control *arg1 = 0 ;
62667   Dali::Toolkit::Internal::Control *result = 0 ;
62668
62669   arg1 = (Dali::Toolkit::Control *)jarg1;
62670   if (!arg1) {
62671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
62672     return 0;
62673   }
62674   {
62675     try {
62676       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
62677     } catch (std::out_of_range& e) {
62678       {
62679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62680       };
62681     } catch (std::exception& e) {
62682       {
62683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62684       };
62685     } catch (Dali::DaliException e) {
62686       {
62687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62688       };
62689     } catch (...) {
62690       {
62691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62692       };
62693     }
62694   }
62695
62696   jresult = (void *)result;
62697   return jresult;
62698 }
62699
62700
62701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
62702   int jresult ;
62703   int result;
62704
62705   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
62706   jresult = (int)result;
62707   return jresult;
62708 }
62709
62710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
62711   int jresult ;
62712   int result;
62713
62714   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
62715   jresult = (int)result;
62716   return jresult;
62717 }
62718
62719
62720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
62721   int jresult ;
62722   int result;
62723
62724   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
62725   jresult = (int)result;
62726   return jresult;
62727 }
62728
62729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
62730   int jresult ;
62731   int result;
62732
62733   result = (int)Dali::Toolkit::Control::Property::MARGIN;
62734   jresult = (int)result;
62735   return jresult;
62736 }
62737
62738
62739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
62740   int jresult ;
62741   int result;
62742
62743   result = (int)Dali::Toolkit::Control::Property::PADDING;
62744   jresult = (int)result;
62745   return jresult;
62746 }
62747
62748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
62749   int jresult ;
62750   int result;
62751
62752   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
62753   jresult = (int)result;
62754   return jresult;
62755 }
62756
62757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
62758   void * jresult ;
62759   Dali::Toolkit::Control::Property *result = 0 ;
62760
62761   {
62762     try {
62763       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
62764     } catch (std::out_of_range& e) {
62765       {
62766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62767       };
62768     } catch (std::exception& e) {
62769       {
62770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62771       };
62772     } catch (Dali::DaliException e) {
62773       {
62774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62775       };
62776     } catch (...) {
62777       {
62778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62779       };
62780     }
62781   }
62782
62783   jresult = (void *)result;
62784   return jresult;
62785 }
62786
62787
62788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
62789   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
62790
62791   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
62792   {
62793     try {
62794       delete arg1;
62795     } catch (std::out_of_range& e) {
62796       {
62797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62798       };
62799     } catch (std::exception& e) {
62800       {
62801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62802       };
62803     } catch (Dali::DaliException e) {
62804       {
62805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62806       };
62807     } catch (...) {
62808       {
62809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62810       };
62811     }
62812   }
62813
62814 }
62815
62816
62817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
62818   void * jresult ;
62819   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
62820
62821   {
62822     try {
62823       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
62824     } catch (std::out_of_range& e) {
62825       {
62826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62827       };
62828     } catch (std::exception& e) {
62829       {
62830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62831       };
62832     } catch (Dali::DaliException e) {
62833       {
62834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62835       };
62836     } catch (...) {
62837       {
62838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62839       };
62840     }
62841   }
62842
62843   jresult = (void *)result;
62844   return jresult;
62845 }
62846
62847
62848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
62849   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
62850
62851   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
62852   {
62853     try {
62854       delete arg1;
62855     } catch (std::out_of_range& e) {
62856       {
62857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62858       };
62859     } catch (std::exception& e) {
62860       {
62861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62862       };
62863     } catch (Dali::DaliException e) {
62864       {
62865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62866       };
62867     } catch (...) {
62868       {
62869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62870       };
62871     }
62872   }
62873
62874 }
62875
62876
62877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
62878   void * jresult ;
62879   Dali::Toolkit::Control result;
62880
62881   {
62882     try {
62883       result = Dali::Toolkit::Control::New();
62884     } catch (std::out_of_range& e) {
62885       {
62886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62887       };
62888     } catch (std::exception& e) {
62889       {
62890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62891       };
62892     } catch (Dali::DaliException e) {
62893       {
62894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62895       };
62896     } catch (...) {
62897       {
62898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62899       };
62900     }
62901   }
62902
62903   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62904   return jresult;
62905 }
62906
62907
62908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
62909   void * jresult ;
62910   Dali::Toolkit::Control *result = 0 ;
62911
62912   {
62913     try {
62914       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
62915     } catch (std::out_of_range& e) {
62916       {
62917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62918       };
62919     } catch (std::exception& e) {
62920       {
62921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62922       };
62923     } catch (Dali::DaliException e) {
62924       {
62925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62926       };
62927     } catch (...) {
62928       {
62929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62930       };
62931     }
62932   }
62933
62934   jresult = (void *)result;
62935   return jresult;
62936 }
62937
62938
62939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
62940   void * jresult ;
62941   Dali::Toolkit::Control *arg1 = 0 ;
62942   Dali::Toolkit::Control *result = 0 ;
62943
62944   arg1 = (Dali::Toolkit::Control *)jarg1;
62945   if (!arg1) {
62946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
62947     return 0;
62948   }
62949   {
62950     try {
62951       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
62952     } catch (std::out_of_range& e) {
62953       {
62954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62955       };
62956     } catch (std::exception& e) {
62957       {
62958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62959       };
62960     } catch (Dali::DaliException e) {
62961       {
62962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62963       };
62964     } catch (...) {
62965       {
62966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62967       };
62968     }
62969   }
62970
62971   jresult = (void *)result;
62972   return jresult;
62973 }
62974
62975
62976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
62977   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62978
62979   arg1 = (Dali::Toolkit::Control *)jarg1;
62980   {
62981     try {
62982       delete arg1;
62983     } catch (std::out_of_range& e) {
62984       {
62985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62986       };
62987     } catch (std::exception& e) {
62988       {
62989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62990       };
62991     } catch (Dali::DaliException e) {
62992       {
62993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62994       };
62995     } catch (...) {
62996       {
62997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62998       };
62999     }
63000   }
63001
63002 }
63003
63004
63005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
63006   void * jresult ;
63007   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63008   Dali::Toolkit::Control *arg2 = 0 ;
63009   Dali::Toolkit::Control *result = 0 ;
63010
63011   arg1 = (Dali::Toolkit::Control *)jarg1;
63012   arg2 = (Dali::Toolkit::Control *)jarg2;
63013   if (!arg2) {
63014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63015     return 0;
63016   }
63017   {
63018     try {
63019       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
63020     } catch (std::out_of_range& e) {
63021       {
63022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63023       };
63024     } catch (std::exception& e) {
63025       {
63026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63027       };
63028     } catch (Dali::DaliException e) {
63029       {
63030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63031       };
63032     } catch (...) {
63033       {
63034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63035       };
63036     }
63037   }
63038
63039   jresult = (void *)result;
63040   return jresult;
63041 }
63042
63043
63044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
63045   void * jresult ;
63046   Dali::BaseHandle arg1 ;
63047   Dali::BaseHandle *argp1 ;
63048   Dali::Toolkit::Control result;
63049
63050   argp1 = (Dali::BaseHandle *)jarg1;
63051   if (!argp1) {
63052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63053     return 0;
63054   }
63055   arg1 = *argp1;
63056   {
63057     try {
63058       result = Dali::Toolkit::Control::DownCast(arg1);
63059     } catch (std::out_of_range& e) {
63060       {
63061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63062       };
63063     } catch (std::exception& e) {
63064       {
63065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63066       };
63067     } catch (Dali::DaliException e) {
63068       {
63069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63070       };
63071     } catch (...) {
63072       {
63073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63074       };
63075     }
63076   }
63077
63078   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63079   return jresult;
63080 }
63081
63082
63083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
63084   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63085
63086   arg1 = (Dali::Toolkit::Control *)jarg1;
63087   {
63088     try {
63089       (arg1)->SetKeyInputFocus();
63090     } catch (std::out_of_range& e) {
63091       {
63092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63093       };
63094     } catch (std::exception& e) {
63095       {
63096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63097       };
63098     } catch (Dali::DaliException e) {
63099       {
63100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63101       };
63102     } catch (...) {
63103       {
63104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63105       };
63106     }
63107   }
63108
63109 }
63110
63111
63112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
63113   unsigned int jresult ;
63114   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63115   bool result;
63116
63117   arg1 = (Dali::Toolkit::Control *)jarg1;
63118   {
63119     try {
63120       result = (bool)(arg1)->HasKeyInputFocus();
63121     } catch (std::out_of_range& e) {
63122       {
63123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63124       };
63125     } catch (std::exception& e) {
63126       {
63127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63128       };
63129     } catch (Dali::DaliException e) {
63130       {
63131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63132       };
63133     } catch (...) {
63134       {
63135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63136       };
63137     }
63138   }
63139
63140   jresult = result;
63141   return jresult;
63142 }
63143
63144
63145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
63146   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63147
63148   arg1 = (Dali::Toolkit::Control *)jarg1;
63149   {
63150     try {
63151       (arg1)->ClearKeyInputFocus();
63152     } catch (std::out_of_range& e) {
63153       {
63154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63155       };
63156     } catch (std::exception& e) {
63157       {
63158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63159       };
63160     } catch (Dali::DaliException e) {
63161       {
63162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63163       };
63164     } catch (...) {
63165       {
63166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63167       };
63168     }
63169   }
63170
63171 }
63172
63173
63174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
63175   void * jresult ;
63176   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63177   Dali::PinchGestureDetector result;
63178
63179   arg1 = (Dali::Toolkit::Control *)jarg1;
63180   {
63181     try {
63182       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
63183     } catch (std::out_of_range& e) {
63184       {
63185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63186       };
63187     } catch (std::exception& e) {
63188       {
63189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63190       };
63191     } catch (Dali::DaliException e) {
63192       {
63193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63194       };
63195     } catch (...) {
63196       {
63197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63198       };
63199     }
63200   }
63201
63202   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63203   return jresult;
63204 }
63205
63206
63207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
63208   void * jresult ;
63209   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63210   Dali::PanGestureDetector result;
63211
63212   arg1 = (Dali::Toolkit::Control *)jarg1;
63213   {
63214     try {
63215       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
63216     } catch (std::out_of_range& e) {
63217       {
63218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63219       };
63220     } catch (std::exception& e) {
63221       {
63222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63223       };
63224     } catch (Dali::DaliException e) {
63225       {
63226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63227       };
63228     } catch (...) {
63229       {
63230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63231       };
63232     }
63233   }
63234
63235   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63236   return jresult;
63237 }
63238
63239
63240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
63241   void * jresult ;
63242   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63243   Dali::TapGestureDetector result;
63244
63245   arg1 = (Dali::Toolkit::Control *)jarg1;
63246   {
63247     try {
63248       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
63249     } catch (std::out_of_range& e) {
63250       {
63251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63252       };
63253     } catch (std::exception& e) {
63254       {
63255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63256       };
63257     } catch (Dali::DaliException e) {
63258       {
63259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63260       };
63261     } catch (...) {
63262       {
63263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63264       };
63265     }
63266   }
63267
63268   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63269   return jresult;
63270 }
63271
63272
63273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
63274   void * jresult ;
63275   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63276   Dali::LongPressGestureDetector result;
63277
63278   arg1 = (Dali::Toolkit::Control *)jarg1;
63279   {
63280     try {
63281       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
63282     } catch (std::out_of_range& e) {
63283       {
63284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63285       };
63286     } catch (std::exception& e) {
63287       {
63288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63289       };
63290     } catch (Dali::DaliException e) {
63291       {
63292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63293       };
63294     } catch (...) {
63295       {
63296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63297       };
63298     }
63299   }
63300
63301   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63302   return jresult;
63303 }
63304
63305
63306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
63307   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63308   std::string *arg2 = 0 ;
63309
63310   arg1 = (Dali::Toolkit::Control *)jarg1;
63311   if (!jarg2) {
63312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63313     return ;
63314   }
63315   std::string arg2_str(jarg2);
63316   arg2 = &arg2_str;
63317   {
63318     try {
63319       (arg1)->SetStyleName((std::string const &)*arg2);
63320     } catch (std::out_of_range& e) {
63321       {
63322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63323       };
63324     } catch (std::exception& e) {
63325       {
63326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63327       };
63328     } catch (Dali::DaliException e) {
63329       {
63330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63331       };
63332     } catch (...) {
63333       {
63334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63335       };
63336     }
63337   }
63338
63339
63340   //argout typemap for const std::string&
63341
63342 }
63343
63344
63345 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
63346   char * jresult ;
63347   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63348   std::string *result = 0 ;
63349
63350   arg1 = (Dali::Toolkit::Control *)jarg1;
63351   {
63352     try {
63353       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
63354     } catch (std::out_of_range& e) {
63355       {
63356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63357       };
63358     } catch (std::exception& e) {
63359       {
63360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63361       };
63362     } catch (Dali::DaliException e) {
63363       {
63364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63365       };
63366     } catch (...) {
63367       {
63368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63369       };
63370     }
63371   }
63372
63373   jresult = SWIG_csharp_string_callback(result->c_str());
63374   return jresult;
63375 }
63376
63377
63378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
63379   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63380   Dali::Vector4 *arg2 = 0 ;
63381
63382   arg1 = (Dali::Toolkit::Control *)jarg1;
63383   arg2 = (Dali::Vector4 *)jarg2;
63384   if (!arg2) {
63385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63386     return ;
63387   }
63388   {
63389     try {
63390       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63391     } catch (std::out_of_range& e) {
63392       {
63393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63394       };
63395     } catch (std::exception& e) {
63396       {
63397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63398       };
63399     } catch (Dali::DaliException e) {
63400       {
63401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63402       };
63403     } catch (...) {
63404       {
63405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63406       };
63407     }
63408   }
63409
63410 }
63411
63412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
63413   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63414
63415   arg1 = (Dali::Toolkit::Control *)jarg1;
63416   {
63417     try {
63418       (arg1)->ClearBackground();
63419     } catch (std::out_of_range& e) {
63420       {
63421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63422       };
63423     } catch (std::exception& e) {
63424       {
63425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63426       };
63427     } catch (Dali::DaliException e) {
63428       {
63429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63430       };
63431     } catch (...) {
63432       {
63433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63434       };
63435     }
63436   }
63437
63438 }
63439
63440
63441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
63442   void * jresult ;
63443   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63444   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63445
63446   arg1 = (Dali::Toolkit::Control *)jarg1;
63447   {
63448     try {
63449       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63450     } catch (std::out_of_range& e) {
63451       {
63452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63453       };
63454     } catch (std::exception& e) {
63455       {
63456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63457       };
63458     } catch (Dali::DaliException e) {
63459       {
63460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63461       };
63462     } catch (...) {
63463       {
63464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63465       };
63466     }
63467   }
63468
63469   jresult = (void *)result;
63470   return jresult;
63471 }
63472
63473
63474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
63475   void * jresult ;
63476   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63477   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63478
63479   arg1 = (Dali::Toolkit::Control *)jarg1;
63480   {
63481     try {
63482       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63483     } catch (std::out_of_range& e) {
63484       {
63485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63486       };
63487     } catch (std::exception& e) {
63488       {
63489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63490       };
63491     } catch (Dali::DaliException e) {
63492       {
63493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63494       };
63495     } catch (...) {
63496       {
63497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63498       };
63499     }
63500   }
63501
63502   jresult = (void *)result;
63503   return jresult;
63504 }
63505
63506
63507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
63508   void * jresult ;
63509   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63510   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63511
63512   arg1 = (Dali::Toolkit::Control *)jarg1;
63513   {
63514     try {
63515       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63516     } catch (std::out_of_range& e) {
63517       {
63518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63519       };
63520     } catch (std::exception& e) {
63521       {
63522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63523       };
63524     } catch (Dali::DaliException e) {
63525       {
63526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63527       };
63528     } catch (...) {
63529       {
63530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63531       };
63532     }
63533   }
63534
63535   jresult = (void *)result;
63536   return jresult;
63537 }
63538
63539
63540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
63541   void * jresult ;
63542   Dali::Toolkit::Internal::Control *arg1 = 0 ;
63543   Dali::Toolkit::Control *result = 0 ;
63544
63545   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63546   if (!arg1) {
63547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
63548     return 0;
63549   }
63550   {
63551     try {
63552       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
63553     } catch (std::out_of_range& e) {
63554       {
63555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63556       };
63557     } catch (std::exception& e) {
63558       {
63559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63560       };
63561     } catch (Dali::DaliException e) {
63562       {
63563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63564       };
63565     } catch (...) {
63566       {
63567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63568       };
63569     }
63570   }
63571
63572   jresult = (void *)result;
63573   return jresult;
63574 }
63575
63576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
63577 {
63578   int jresult;
63579   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63580   arg1 = (Dali::Toolkit::Control *)jarg1;
63581
63582   if (!arg1) {
63583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63584     return 0;
63585   }
63586
63587   Dali::Property::Index arg2 = 0 ;
63588   arg2 = (Dali::Property::Index)jarg2;
63589
63590   Toolkit::Visual::ResourceStatus result;
63591   {
63592     try {
63593       result = arg1->GetVisualResourceStatus(arg2);
63594     } catch (std::out_of_range& e) {
63595       {
63596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63597       };
63598     } catch (std::exception& e) {
63599       {
63600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63601       };
63602     } catch (...) {
63603       {
63604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63605       };
63606     }
63607   }
63608   jresult = (int)(result);
63609   return jresult;
63610 }
63611
63612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
63613 {
63614   void * jresult;
63615   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63616   arg1 = (Dali::Toolkit::Control *)jarg1;
63617
63618   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
63619
63620   Dali::Toolkit::TransitionData *arg2 = 0 ;
63621   Dali::Animation result;
63622
63623   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
63624   if (!arg2) {
63625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
63626     return 0;
63627   }
63628   {
63629     try {
63630       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
63631     } catch (std::out_of_range& e) {
63632       {
63633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63634       };
63635     } catch (std::exception& e) {
63636       {
63637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63638       };
63639     } catch (Dali::DaliException e) {
63640       {
63641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63642       };
63643     } catch (...) {
63644       {
63645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63646       };
63647     }
63648   }
63649
63650   jresult = new Dali::Animation((const Dali::Animation &)result);
63651   return jresult;
63652 }
63653
63654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
63655 {
63656   Dali::Toolkit::Control arg1;
63657   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
63658
63659   if (!argp1) {
63660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63661   }
63662   arg1 = *argp1;
63663
63664   Dali::Property::Index arg2 = 0 ;
63665   arg2 = (Dali::Property::Index)jarg2;
63666
63667   Dali::Property::Index arg3 = 0 ;
63668   arg3 = (Dali::Property::Index)jarg3;
63669
63670   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
63671
63672   {
63673     try {
63674       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
63675     } catch (std::out_of_range& e) {
63676       {
63677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63678       };
63679     } catch (std::exception& e) {
63680       {
63681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63682       };
63683     } catch (...) {
63684       {
63685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63686       };
63687     }
63688   }
63689
63690
63691 }
63692
63693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
63694   void * jresult ;
63695   Dali::Toolkit::Control *arg1 = 0 ;
63696   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
63697
63698   arg1 = (Dali::Toolkit::Control *)jarg1;
63699   if (!arg1) {
63700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63701     return 0;
63702   }
63703   {
63704     try {
63705       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
63706     } catch (std::out_of_range& e) {
63707       {
63708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63709       };
63710     } catch (std::exception& e) {
63711       {
63712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63713       };
63714     } catch (Dali::DaliException e) {
63715       {
63716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63717       };
63718     } catch (...) {
63719       {
63720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63721       };
63722     }
63723   }
63724
63725   jresult = (void *)result;
63726   return jresult;
63727 }
63728
63729
63730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
63731   unsigned int jresult ;
63732   Dali::Toolkit::Control *arg1 = 0 ;
63733   bool result;
63734
63735   arg1 = (Dali::Toolkit::Control *)jarg1;
63736   if (!arg1) {
63737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63738     return 0;
63739   }
63740   {
63741     try {
63742       result = (bool)arg1->IsResourceReady();
63743     } catch (std::out_of_range& e) {
63744       {
63745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63746       };
63747     } catch (std::exception& e) {
63748       {
63749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63750       };
63751     } catch (Dali::DaliException e) {
63752       {
63753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63754       };
63755     } catch (...) {
63756       {
63757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63758       };
63759     }
63760   }
63761
63762   jresult = result;
63763   return jresult;
63764 }
63765
63766
63767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
63768   void * jresult ;
63769   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
63770
63771   {
63772     try {
63773       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
63774     } catch (std::out_of_range& e) {
63775       {
63776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63777       };
63778     } catch (std::exception& e) {
63779       {
63780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63781       };
63782     } catch (Dali::DaliException e) {
63783       {
63784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63785       };
63786     } catch (...) {
63787       {
63788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63789       };
63790     }
63791   }
63792
63793   jresult = (void *)result;
63794   return jresult;
63795 }
63796
63797
63798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
63799   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63800
63801   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63802   {
63803     try {
63804       delete arg1;
63805     } catch (std::out_of_range& e) {
63806       {
63807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63808       };
63809     } catch (std::exception& e) {
63810       {
63811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63812       };
63813     } catch (Dali::DaliException e) {
63814       {
63815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63816       };
63817     } catch (...) {
63818       {
63819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63820       };
63821     }
63822   }
63823
63824 }
63825
63826
63827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
63828   void * jresult ;
63829   Dali::Toolkit::KeyInputFocusManager result;
63830
63831   {
63832     try {
63833       result = Dali::Toolkit::KeyInputFocusManager::Get();
63834     } catch (std::out_of_range& e) {
63835       {
63836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63837       };
63838     } catch (std::exception& e) {
63839       {
63840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63841       };
63842     } catch (Dali::DaliException e) {
63843       {
63844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63845       };
63846     } catch (...) {
63847       {
63848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63849       };
63850     }
63851   }
63852
63853   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
63854   return jresult;
63855 }
63856
63857
63858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
63859   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63860   Dali::Toolkit::Control arg2 ;
63861   Dali::Toolkit::Control *argp2 ;
63862
63863   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63864   argp2 = (Dali::Toolkit::Control *)jarg2;
63865   if (!argp2) {
63866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63867     return ;
63868   }
63869   arg2 = *argp2;
63870   {
63871     try {
63872       (arg1)->SetFocus(arg2);
63873     } catch (std::out_of_range& e) {
63874       {
63875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63876       };
63877     } catch (std::exception& e) {
63878       {
63879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63880       };
63881     } catch (Dali::DaliException e) {
63882       {
63883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63884       };
63885     } catch (...) {
63886       {
63887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63888       };
63889     }
63890   }
63891
63892 }
63893
63894
63895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
63896   void * jresult ;
63897   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63898   Dali::Toolkit::Control result;
63899
63900   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63901   {
63902     try {
63903       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
63904     } catch (std::out_of_range& e) {
63905       {
63906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63907       };
63908     } catch (std::exception& e) {
63909       {
63910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63911       };
63912     } catch (Dali::DaliException e) {
63913       {
63914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63915       };
63916     } catch (...) {
63917       {
63918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63919       };
63920     }
63921   }
63922
63923   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63924   return jresult;
63925 }
63926
63927
63928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
63929   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63930   Dali::Toolkit::Control arg2 ;
63931   Dali::Toolkit::Control *argp2 ;
63932
63933   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63934   argp2 = (Dali::Toolkit::Control *)jarg2;
63935   if (!argp2) {
63936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63937     return ;
63938   }
63939   arg2 = *argp2;
63940   {
63941     try {
63942       (arg1)->RemoveFocus(arg2);
63943     } catch (std::out_of_range& e) {
63944       {
63945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63946       };
63947     } catch (std::exception& e) {
63948       {
63949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63950       };
63951     } catch (Dali::DaliException e) {
63952       {
63953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63954       };
63955     } catch (...) {
63956       {
63957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63958       };
63959     }
63960   }
63961
63962 }
63963
63964
63965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
63966   void * jresult ;
63967   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63968   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
63969
63970   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63971   {
63972     try {
63973       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
63974     } catch (std::out_of_range& e) {
63975       {
63976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63977       };
63978     } catch (std::exception& e) {
63979       {
63980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63981       };
63982     } catch (Dali::DaliException e) {
63983       {
63984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63985       };
63986     } catch (...) {
63987       {
63988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63989       };
63990     }
63991   }
63992
63993   jresult = (void *)result;
63994   return jresult;
63995 }
63996
63997
63998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
63999   void * jresult ;
64000   Dali::Toolkit::Alignment::Padding *result = 0 ;
64001
64002   {
64003     try {
64004       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
64005     } catch (std::out_of_range& e) {
64006       {
64007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64008       };
64009     } catch (std::exception& e) {
64010       {
64011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64012       };
64013     } catch (Dali::DaliException e) {
64014       {
64015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64016       };
64017     } catch (...) {
64018       {
64019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64020       };
64021     }
64022   }
64023
64024   jresult = (void *)result;
64025   return jresult;
64026 }
64027
64028
64029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
64030   void * jresult ;
64031   float arg1 ;
64032   float arg2 ;
64033   float arg3 ;
64034   float arg4 ;
64035   Dali::Toolkit::Alignment::Padding *result = 0 ;
64036
64037   arg1 = (float)jarg1;
64038   arg2 = (float)jarg2;
64039   arg3 = (float)jarg3;
64040   arg4 = (float)jarg4;
64041   {
64042     try {
64043       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
64044     } catch (std::out_of_range& e) {
64045       {
64046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64047       };
64048     } catch (std::exception& e) {
64049       {
64050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64051       };
64052     } catch (Dali::DaliException e) {
64053       {
64054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64055       };
64056     } catch (...) {
64057       {
64058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64059       };
64060     }
64061   }
64062
64063   jresult = (void *)result;
64064   return jresult;
64065 }
64066
64067
64068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
64069   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64070   float arg2 ;
64071
64072   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64073   arg2 = (float)jarg2;
64074   if (arg1) (arg1)->left = arg2;
64075 }
64076
64077
64078 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
64079   float jresult ;
64080   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64081   float result;
64082
64083   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64084   result = (float) ((arg1)->left);
64085   jresult = result;
64086   return jresult;
64087 }
64088
64089
64090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
64091   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64092   float arg2 ;
64093
64094   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64095   arg2 = (float)jarg2;
64096   if (arg1) (arg1)->right = arg2;
64097 }
64098
64099
64100 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
64101   float jresult ;
64102   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64103   float result;
64104
64105   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64106   result = (float) ((arg1)->right);
64107   jresult = result;
64108   return jresult;
64109 }
64110
64111
64112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
64113   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64114   float arg2 ;
64115
64116   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64117   arg2 = (float)jarg2;
64118   if (arg1) (arg1)->top = arg2;
64119 }
64120
64121
64122 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
64123   float jresult ;
64124   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64125   float result;
64126
64127   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64128   result = (float) ((arg1)->top);
64129   jresult = result;
64130   return jresult;
64131 }
64132
64133
64134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
64135   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64136   float arg2 ;
64137
64138   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64139   arg2 = (float)jarg2;
64140   if (arg1) (arg1)->bottom = arg2;
64141 }
64142
64143
64144 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
64145   float jresult ;
64146   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64147   float result;
64148
64149   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64150   result = (float) ((arg1)->bottom);
64151   jresult = result;
64152   return jresult;
64153 }
64154
64155
64156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
64157   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64158
64159   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64160   {
64161     try {
64162       delete arg1;
64163     } catch (std::out_of_range& e) {
64164       {
64165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64166       };
64167     } catch (std::exception& e) {
64168       {
64169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64170       };
64171     } catch (Dali::DaliException e) {
64172       {
64173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64174       };
64175     } catch (...) {
64176       {
64177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64178       };
64179     }
64180   }
64181
64182 }
64183
64184
64185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
64186   void * jresult ;
64187   Dali::Toolkit::Alignment *result = 0 ;
64188
64189   {
64190     try {
64191       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
64192     } catch (std::out_of_range& e) {
64193       {
64194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64195       };
64196     } catch (std::exception& e) {
64197       {
64198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64199       };
64200     } catch (Dali::DaliException e) {
64201       {
64202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64203       };
64204     } catch (...) {
64205       {
64206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64207       };
64208     }
64209   }
64210
64211   jresult = (void *)result;
64212   return jresult;
64213 }
64214
64215
64216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
64217   void * jresult ;
64218   Dali::Toolkit::Alignment::Type arg1 ;
64219   Dali::Toolkit::Alignment::Type arg2 ;
64220   Dali::Toolkit::Alignment result;
64221
64222   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64223   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64224   {
64225     try {
64226       result = Dali::Toolkit::Alignment::New(arg1,arg2);
64227     } catch (std::out_of_range& e) {
64228       {
64229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64230       };
64231     } catch (std::exception& e) {
64232       {
64233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64234       };
64235     } catch (Dali::DaliException e) {
64236       {
64237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64238       };
64239     } catch (...) {
64240       {
64241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64242       };
64243     }
64244   }
64245
64246   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64247   return jresult;
64248 }
64249
64250
64251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
64252   void * jresult ;
64253   Dali::Toolkit::Alignment::Type arg1 ;
64254   Dali::Toolkit::Alignment result;
64255
64256   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64257   {
64258     try {
64259       result = Dali::Toolkit::Alignment::New(arg1);
64260     } catch (std::out_of_range& e) {
64261       {
64262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64263       };
64264     } catch (std::exception& e) {
64265       {
64266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64267       };
64268     } catch (Dali::DaliException e) {
64269       {
64270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64271       };
64272     } catch (...) {
64273       {
64274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64275       };
64276     }
64277   }
64278
64279   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64280   return jresult;
64281 }
64282
64283
64284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
64285   void * jresult ;
64286   Dali::Toolkit::Alignment result;
64287
64288   {
64289     try {
64290       result = Dali::Toolkit::Alignment::New();
64291     } catch (std::out_of_range& e) {
64292       {
64293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64294       };
64295     } catch (std::exception& e) {
64296       {
64297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64298       };
64299     } catch (Dali::DaliException e) {
64300       {
64301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64302       };
64303     } catch (...) {
64304       {
64305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64306       };
64307     }
64308   }
64309
64310   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64311   return jresult;
64312 }
64313
64314
64315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
64316   void * jresult ;
64317   Dali::Toolkit::Alignment *arg1 = 0 ;
64318   Dali::Toolkit::Alignment *result = 0 ;
64319
64320   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64321   if (!arg1) {
64322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64323     return 0;
64324   }
64325   {
64326     try {
64327       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
64328     } catch (std::out_of_range& e) {
64329       {
64330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64331       };
64332     } catch (std::exception& e) {
64333       {
64334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64335       };
64336     } catch (Dali::DaliException e) {
64337       {
64338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64339       };
64340     } catch (...) {
64341       {
64342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64343       };
64344     }
64345   }
64346
64347   jresult = (void *)result;
64348   return jresult;
64349 }
64350
64351
64352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
64353   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64354
64355   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64356   {
64357     try {
64358       delete arg1;
64359     } catch (std::out_of_range& e) {
64360       {
64361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64362       };
64363     } catch (std::exception& e) {
64364       {
64365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64366       };
64367     } catch (Dali::DaliException e) {
64368       {
64369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64370       };
64371     } catch (...) {
64372       {
64373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64374       };
64375     }
64376   }
64377
64378 }
64379
64380
64381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
64382   void * jresult ;
64383   Dali::BaseHandle arg1 ;
64384   Dali::BaseHandle *argp1 ;
64385   Dali::Toolkit::Alignment result;
64386
64387   argp1 = (Dali::BaseHandle *)jarg1;
64388   if (!argp1) {
64389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64390     return 0;
64391   }
64392   arg1 = *argp1;
64393   {
64394     try {
64395       result = Dali::Toolkit::Alignment::DownCast(arg1);
64396     } catch (std::out_of_range& e) {
64397       {
64398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64399       };
64400     } catch (std::exception& e) {
64401       {
64402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64403       };
64404     } catch (Dali::DaliException e) {
64405       {
64406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64407       };
64408     } catch (...) {
64409       {
64410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64411       };
64412     }
64413   }
64414
64415   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64416   return jresult;
64417 }
64418
64419
64420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
64421   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64422   Dali::Toolkit::Alignment::Type arg2 ;
64423
64424   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64425   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64426   {
64427     try {
64428       (arg1)->SetAlignmentType(arg2);
64429     } catch (std::out_of_range& e) {
64430       {
64431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64432       };
64433     } catch (std::exception& e) {
64434       {
64435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64436       };
64437     } catch (Dali::DaliException e) {
64438       {
64439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64440       };
64441     } catch (...) {
64442       {
64443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64444       };
64445     }
64446   }
64447
64448 }
64449
64450
64451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
64452   int jresult ;
64453   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64454   Dali::Toolkit::Alignment::Type result;
64455
64456   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64457   {
64458     try {
64459       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
64460     } catch (std::out_of_range& e) {
64461       {
64462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64463       };
64464     } catch (std::exception& e) {
64465       {
64466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64467       };
64468     } catch (Dali::DaliException e) {
64469       {
64470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64471       };
64472     } catch (...) {
64473       {
64474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64475       };
64476     }
64477   }
64478
64479   jresult = (int)result;
64480   return jresult;
64481 }
64482
64483
64484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
64485   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64486   Dali::Toolkit::Alignment::Scaling arg2 ;
64487
64488   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64489   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
64490   {
64491     try {
64492       (arg1)->SetScaling(arg2);
64493     } catch (std::out_of_range& e) {
64494       {
64495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64496       };
64497     } catch (std::exception& e) {
64498       {
64499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64500       };
64501     } catch (Dali::DaliException e) {
64502       {
64503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64504       };
64505     } catch (...) {
64506       {
64507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64508       };
64509     }
64510   }
64511
64512 }
64513
64514
64515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
64516   int jresult ;
64517   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64518   Dali::Toolkit::Alignment::Scaling result;
64519
64520   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64521   {
64522     try {
64523       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
64524     } catch (std::out_of_range& e) {
64525       {
64526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64527       };
64528     } catch (std::exception& e) {
64529       {
64530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64531       };
64532     } catch (Dali::DaliException e) {
64533       {
64534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64535       };
64536     } catch (...) {
64537       {
64538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64539       };
64540     }
64541   }
64542
64543   jresult = (int)result;
64544   return jresult;
64545 }
64546
64547
64548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
64549   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64550   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
64551
64552   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64553   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
64554   if (!arg2) {
64555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
64556     return ;
64557   }
64558   {
64559     try {
64560       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
64561     } catch (std::out_of_range& e) {
64562       {
64563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64564       };
64565     } catch (std::exception& e) {
64566       {
64567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64568       };
64569     } catch (Dali::DaliException e) {
64570       {
64571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64572       };
64573     } catch (...) {
64574       {
64575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64576       };
64577     }
64578   }
64579
64580 }
64581
64582
64583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
64584   void * jresult ;
64585   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64586   Dali::Toolkit::Alignment::Padding *result = 0 ;
64587
64588   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64589   {
64590     try {
64591       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
64592     } catch (std::out_of_range& e) {
64593       {
64594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64595       };
64596     } catch (std::exception& e) {
64597       {
64598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64599       };
64600     } catch (Dali::DaliException e) {
64601       {
64602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64603       };
64604     } catch (...) {
64605       {
64606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64607       };
64608     }
64609   }
64610
64611   jresult = (void *)result;
64612   return jresult;
64613 }
64614
64615
64616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
64617   void * jresult ;
64618   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64619   Dali::Toolkit::Alignment *arg2 = 0 ;
64620   Dali::Toolkit::Alignment *result = 0 ;
64621
64622   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64623   arg2 = (Dali::Toolkit::Alignment *)jarg2;
64624   if (!arg2) {
64625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64626     return 0;
64627   }
64628   {
64629     try {
64630       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
64631     } catch (std::out_of_range& e) {
64632       {
64633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64634       };
64635     } catch (std::exception& e) {
64636       {
64637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64638       };
64639     } catch (Dali::DaliException e) {
64640       {
64641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64642       };
64643     } catch (...) {
64644       {
64645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64646       };
64647     }
64648   }
64649
64650   jresult = (void *)result;
64651   return jresult;
64652 }
64653
64654
64655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
64656   int jresult ;
64657   int result;
64658
64659   result = (int)Dali::Toolkit::Button::Property::DISABLED;
64660   jresult = (int)result;
64661   return jresult;
64662 }
64663
64664
64665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
64666   int jresult ;
64667   int result;
64668
64669   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
64670   jresult = (int)result;
64671   return jresult;
64672 }
64673
64674
64675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
64676   int jresult ;
64677   int result;
64678
64679   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
64680   jresult = (int)result;
64681   return jresult;
64682 }
64683
64684
64685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
64686   int jresult ;
64687   int result;
64688
64689   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
64690   jresult = (int)result;
64691   return jresult;
64692 }
64693
64694
64695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
64696   int jresult ;
64697   int result;
64698
64699   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
64700   jresult = (int)result;
64701   return jresult;
64702 }
64703
64704
64705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
64706   int jresult ;
64707   int result;
64708
64709   result = (int)Dali::Toolkit::Button::Property::SELECTED;
64710   jresult = (int)result;
64711   return jresult;
64712 }
64713
64714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
64715   int jresult ;
64716   int result;
64717
64718   result = (int)Dali::Toolkit::Button::Property::LABEL;
64719   jresult = (int)result;
64720   return jresult;
64721 }
64722
64723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
64724   void * jresult ;
64725   Dali::Toolkit::Button::Property *result = 0 ;
64726
64727   {
64728     try {
64729       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
64730     } catch (std::out_of_range& e) {
64731       {
64732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64733       };
64734     } catch (std::exception& e) {
64735       {
64736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64737       };
64738     } catch (Dali::DaliException e) {
64739       {
64740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64741       };
64742     } catch (...) {
64743       {
64744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64745       };
64746     }
64747   }
64748
64749   jresult = (void *)result;
64750   return jresult;
64751 }
64752
64753
64754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
64755   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
64756
64757   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
64758   {
64759     try {
64760       delete arg1;
64761     } catch (std::out_of_range& e) {
64762       {
64763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64764       };
64765     } catch (std::exception& e) {
64766       {
64767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64768       };
64769     } catch (Dali::DaliException e) {
64770       {
64771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64772       };
64773     } catch (...) {
64774       {
64775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64776       };
64777     }
64778   }
64779
64780 }
64781
64782
64783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
64784   void * jresult ;
64785   Dali::Toolkit::Button *result = 0 ;
64786
64787   {
64788     try {
64789       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
64790     } catch (std::out_of_range& e) {
64791       {
64792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64793       };
64794     } catch (std::exception& e) {
64795       {
64796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64797       };
64798     } catch (Dali::DaliException e) {
64799       {
64800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64801       };
64802     } catch (...) {
64803       {
64804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64805       };
64806     }
64807   }
64808
64809   jresult = (void *)result;
64810   return jresult;
64811 }
64812
64813
64814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
64815   void * jresult ;
64816   Dali::Toolkit::Button *arg1 = 0 ;
64817   Dali::Toolkit::Button *result = 0 ;
64818
64819   arg1 = (Dali::Toolkit::Button *)jarg1;
64820   if (!arg1) {
64821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64822     return 0;
64823   }
64824   {
64825     try {
64826       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
64827     } catch (std::out_of_range& e) {
64828       {
64829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64830       };
64831     } catch (std::exception& e) {
64832       {
64833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64834       };
64835     } catch (Dali::DaliException e) {
64836       {
64837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64838       };
64839     } catch (...) {
64840       {
64841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64842       };
64843     }
64844   }
64845
64846   jresult = (void *)result;
64847   return jresult;
64848 }
64849
64850
64851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
64852   void * jresult ;
64853   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64854   Dali::Toolkit::Button *arg2 = 0 ;
64855   Dali::Toolkit::Button *result = 0 ;
64856
64857   arg1 = (Dali::Toolkit::Button *)jarg1;
64858   arg2 = (Dali::Toolkit::Button *)jarg2;
64859   if (!arg2) {
64860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64861     return 0;
64862   }
64863   {
64864     try {
64865       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
64866     } catch (std::out_of_range& e) {
64867       {
64868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64869       };
64870     } catch (std::exception& e) {
64871       {
64872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64873       };
64874     } catch (Dali::DaliException e) {
64875       {
64876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64877       };
64878     } catch (...) {
64879       {
64880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64881       };
64882     }
64883   }
64884
64885   jresult = (void *)result;
64886   return jresult;
64887 }
64888
64889
64890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
64891   void * jresult ;
64892   Dali::BaseHandle arg1 ;
64893   Dali::BaseHandle *argp1 ;
64894   Dali::Toolkit::Button result;
64895
64896   argp1 = (Dali::BaseHandle *)jarg1;
64897   if (!argp1) {
64898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64899     return 0;
64900   }
64901   arg1 = *argp1;
64902   {
64903     try {
64904       result = Dali::Toolkit::Button::DownCast(arg1);
64905     } catch (std::out_of_range& e) {
64906       {
64907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64908       };
64909     } catch (std::exception& e) {
64910       {
64911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64912       };
64913     } catch (Dali::DaliException e) {
64914       {
64915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64916       };
64917     } catch (...) {
64918       {
64919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64920       };
64921     }
64922   }
64923
64924   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
64925   return jresult;
64926 }
64927
64928
64929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
64930   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64931
64932   arg1 = (Dali::Toolkit::Button *)jarg1;
64933   {
64934     try {
64935       delete arg1;
64936     } catch (std::out_of_range& e) {
64937       {
64938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64939       };
64940     } catch (std::exception& e) {
64941       {
64942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64943       };
64944     } catch (Dali::DaliException e) {
64945       {
64946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64947       };
64948     } catch (...) {
64949       {
64950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64951       };
64952     }
64953   }
64954
64955 }
64956
64957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
64958   void * jresult ;
64959   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64960   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64961
64962   arg1 = (Dali::Toolkit::Button *)jarg1;
64963   {
64964     try {
64965       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
64966     } catch (std::out_of_range& e) {
64967       {
64968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64969       };
64970     } catch (std::exception& e) {
64971       {
64972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64973       };
64974     } catch (Dali::DaliException e) {
64975       {
64976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64977       };
64978     } catch (...) {
64979       {
64980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64981       };
64982     }
64983   }
64984
64985   jresult = (void *)result;
64986   return jresult;
64987 }
64988
64989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
64990   void * jresult ;
64991   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64992   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64993
64994   arg1 = (Dali::Toolkit::Button *)jarg1;
64995   {
64996     try {
64997       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
64998     } catch (std::out_of_range& e) {
64999       {
65000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65001       };
65002     } catch (std::exception& e) {
65003       {
65004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65005       };
65006     } catch (Dali::DaliException e) {
65007       {
65008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65009       };
65010     } catch (...) {
65011       {
65012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65013       };
65014     }
65015   }
65016
65017   jresult = (void *)result;
65018   return jresult;
65019 }
65020
65021
65022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
65023   void * jresult ;
65024   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65025   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65026
65027   arg1 = (Dali::Toolkit::Button *)jarg1;
65028   {
65029     try {
65030       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
65031     } catch (std::out_of_range& e) {
65032       {
65033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65034       };
65035     } catch (std::exception& e) {
65036       {
65037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65038       };
65039     } catch (Dali::DaliException e) {
65040       {
65041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65042       };
65043     } catch (...) {
65044       {
65045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65046       };
65047     }
65048   }
65049
65050   jresult = (void *)result;
65051   return jresult;
65052 }
65053
65054
65055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
65056   void * jresult ;
65057   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65058   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65059
65060   arg1 = (Dali::Toolkit::Button *)jarg1;
65061   {
65062     try {
65063       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
65064     } catch (std::out_of_range& e) {
65065       {
65066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65067       };
65068     } catch (std::exception& e) {
65069       {
65070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65071       };
65072     } catch (Dali::DaliException e) {
65073       {
65074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65075       };
65076     } catch (...) {
65077       {
65078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65079       };
65080     }
65081   }
65082
65083   jresult = (void *)result;
65084   return jresult;
65085 }
65086
65087
65088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
65089   void * jresult ;
65090   Dali::Toolkit::CheckBoxButton *result = 0 ;
65091
65092   {
65093     try {
65094       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
65095     } catch (std::out_of_range& e) {
65096       {
65097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65098       };
65099     } catch (std::exception& e) {
65100       {
65101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65102       };
65103     } catch (Dali::DaliException e) {
65104       {
65105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65106       };
65107     } catch (...) {
65108       {
65109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65110       };
65111     }
65112   }
65113
65114   jresult = (void *)result;
65115   return jresult;
65116 }
65117
65118
65119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
65120   void * jresult ;
65121   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
65122   Dali::Toolkit::CheckBoxButton *result = 0 ;
65123
65124   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65125   if (!arg1) {
65126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65127     return 0;
65128   }
65129   {
65130     try {
65131       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
65132     } catch (std::out_of_range& e) {
65133       {
65134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65135       };
65136     } catch (std::exception& e) {
65137       {
65138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65139       };
65140     } catch (Dali::DaliException e) {
65141       {
65142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65143       };
65144     } catch (...) {
65145       {
65146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65147       };
65148     }
65149   }
65150
65151   jresult = (void *)result;
65152   return jresult;
65153 }
65154
65155
65156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
65157   void * jresult ;
65158   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65159   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
65160   Dali::Toolkit::CheckBoxButton *result = 0 ;
65161
65162   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65163   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
65164   if (!arg2) {
65165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65166     return 0;
65167   }
65168   {
65169     try {
65170       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
65171     } catch (std::out_of_range& e) {
65172       {
65173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65174       };
65175     } catch (std::exception& e) {
65176       {
65177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65178       };
65179     } catch (Dali::DaliException e) {
65180       {
65181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65182       };
65183     } catch (...) {
65184       {
65185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65186       };
65187     }
65188   }
65189
65190   jresult = (void *)result;
65191   return jresult;
65192 }
65193
65194
65195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
65196   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65197
65198   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65199   {
65200     try {
65201       delete arg1;
65202     } catch (std::out_of_range& e) {
65203       {
65204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65205       };
65206     } catch (std::exception& e) {
65207       {
65208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65209       };
65210     } catch (Dali::DaliException e) {
65211       {
65212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65213       };
65214     } catch (...) {
65215       {
65216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65217       };
65218     }
65219   }
65220
65221 }
65222
65223
65224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
65225   void * jresult ;
65226   Dali::Toolkit::CheckBoxButton result;
65227
65228   {
65229     try {
65230       result = Dali::Toolkit::CheckBoxButton::New();
65231     } catch (std::out_of_range& e) {
65232       {
65233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65234       };
65235     } catch (std::exception& e) {
65236       {
65237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65238       };
65239     } catch (Dali::DaliException e) {
65240       {
65241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65242       };
65243     } catch (...) {
65244       {
65245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65246       };
65247     }
65248   }
65249
65250   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65251   return jresult;
65252 }
65253
65254
65255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
65256   void * jresult ;
65257   Dali::BaseHandle arg1 ;
65258   Dali::BaseHandle *argp1 ;
65259   Dali::Toolkit::CheckBoxButton result;
65260
65261   argp1 = (Dali::BaseHandle *)jarg1;
65262   if (!argp1) {
65263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65264     return 0;
65265   }
65266   arg1 = *argp1;
65267   {
65268     try {
65269       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
65270     } catch (std::out_of_range& e) {
65271       {
65272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65273       };
65274     } catch (std::exception& e) {
65275       {
65276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65277       };
65278     } catch (Dali::DaliException e) {
65279       {
65280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65281       };
65282     } catch (...) {
65283       {
65284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65285       };
65286     }
65287   }
65288
65289   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65290   return jresult;
65291 }
65292
65293
65294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
65295   int jresult ;
65296   int result;
65297
65298   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
65299   jresult = (int)result;
65300   return jresult;
65301 }
65302
65303
65304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
65305   int jresult ;
65306   int result;
65307
65308   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
65309   jresult = (int)result;
65310   return jresult;
65311 }
65312
65313
65314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
65315   void * jresult ;
65316   Dali::Toolkit::PushButton::Property *result = 0 ;
65317
65318   {
65319     try {
65320       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
65321     } catch (std::out_of_range& e) {
65322       {
65323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65324       };
65325     } catch (std::exception& e) {
65326       {
65327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65328       };
65329     } catch (Dali::DaliException e) {
65330       {
65331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65332       };
65333     } catch (...) {
65334       {
65335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65336       };
65337     }
65338   }
65339
65340   jresult = (void *)result;
65341   return jresult;
65342 }
65343
65344
65345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
65346   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
65347
65348   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
65349   {
65350     try {
65351       delete arg1;
65352     } catch (std::out_of_range& e) {
65353       {
65354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65355       };
65356     } catch (std::exception& e) {
65357       {
65358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65359       };
65360     } catch (Dali::DaliException e) {
65361       {
65362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65363       };
65364     } catch (...) {
65365       {
65366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65367       };
65368     }
65369   }
65370
65371 }
65372
65373
65374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
65375   void * jresult ;
65376   Dali::Toolkit::PushButton *result = 0 ;
65377
65378   {
65379     try {
65380       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
65381     } catch (std::out_of_range& e) {
65382       {
65383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65384       };
65385     } catch (std::exception& e) {
65386       {
65387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65388       };
65389     } catch (Dali::DaliException e) {
65390       {
65391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65392       };
65393     } catch (...) {
65394       {
65395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65396       };
65397     }
65398   }
65399
65400   jresult = (void *)result;
65401   return jresult;
65402 }
65403
65404
65405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
65406   void * jresult ;
65407   Dali::Toolkit::PushButton *arg1 = 0 ;
65408   Dali::Toolkit::PushButton *result = 0 ;
65409
65410   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65411   if (!arg1) {
65412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65413     return 0;
65414   }
65415   {
65416     try {
65417       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
65418     } catch (std::out_of_range& e) {
65419       {
65420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65421       };
65422     } catch (std::exception& e) {
65423       {
65424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65425       };
65426     } catch (Dali::DaliException e) {
65427       {
65428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65429       };
65430     } catch (...) {
65431       {
65432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65433       };
65434     }
65435   }
65436
65437   jresult = (void *)result;
65438   return jresult;
65439 }
65440
65441
65442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
65443   void * jresult ;
65444   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65445   Dali::Toolkit::PushButton *arg2 = 0 ;
65446   Dali::Toolkit::PushButton *result = 0 ;
65447
65448   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65449   arg2 = (Dali::Toolkit::PushButton *)jarg2;
65450   if (!arg2) {
65451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65452     return 0;
65453   }
65454   {
65455     try {
65456       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
65457     } catch (std::out_of_range& e) {
65458       {
65459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65460       };
65461     } catch (std::exception& e) {
65462       {
65463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65464       };
65465     } catch (Dali::DaliException e) {
65466       {
65467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65468       };
65469     } catch (...) {
65470       {
65471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65472       };
65473     }
65474   }
65475
65476   jresult = (void *)result;
65477   return jresult;
65478 }
65479
65480
65481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
65482   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65483
65484   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65485   {
65486     try {
65487       delete arg1;
65488     } catch (std::out_of_range& e) {
65489       {
65490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65491       };
65492     } catch (std::exception& e) {
65493       {
65494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65495       };
65496     } catch (Dali::DaliException e) {
65497       {
65498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65499       };
65500     } catch (...) {
65501       {
65502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65503       };
65504     }
65505   }
65506
65507 }
65508
65509
65510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
65511   void * jresult ;
65512   Dali::Toolkit::PushButton result;
65513
65514   {
65515     try {
65516       result = Dali::Toolkit::PushButton::New();
65517     } catch (std::out_of_range& e) {
65518       {
65519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65520       };
65521     } catch (std::exception& e) {
65522       {
65523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65524       };
65525     } catch (Dali::DaliException e) {
65526       {
65527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65528       };
65529     } catch (...) {
65530       {
65531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65532       };
65533     }
65534   }
65535
65536   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65537   return jresult;
65538 }
65539
65540
65541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
65542   void * jresult ;
65543   Dali::BaseHandle arg1 ;
65544   Dali::BaseHandle *argp1 ;
65545   Dali::Toolkit::PushButton result;
65546
65547   argp1 = (Dali::BaseHandle *)jarg1;
65548   if (!argp1) {
65549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65550     return 0;
65551   }
65552   arg1 = *argp1;
65553   {
65554     try {
65555       result = Dali::Toolkit::PushButton::DownCast(arg1);
65556     } catch (std::out_of_range& e) {
65557       {
65558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65559       };
65560     } catch (std::exception& e) {
65561       {
65562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65563       };
65564     } catch (Dali::DaliException e) {
65565       {
65566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65567       };
65568     } catch (...) {
65569       {
65570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65571       };
65572     }
65573   }
65574
65575   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65576   return jresult;
65577 }
65578
65579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
65580   void * jresult ;
65581   Dali::Toolkit::RadioButton *result = 0 ;
65582
65583   {
65584     try {
65585       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
65586     } catch (std::out_of_range& e) {
65587       {
65588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65589       };
65590     } catch (std::exception& e) {
65591       {
65592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65593       };
65594     } catch (Dali::DaliException e) {
65595       {
65596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65597       };
65598     } catch (...) {
65599       {
65600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65601       };
65602     }
65603   }
65604
65605   jresult = (void *)result;
65606   return jresult;
65607 }
65608
65609
65610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
65611   void * jresult ;
65612   Dali::Toolkit::RadioButton *arg1 = 0 ;
65613   Dali::Toolkit::RadioButton *result = 0 ;
65614
65615   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65616   if (!arg1) {
65617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65618     return 0;
65619   }
65620   {
65621     try {
65622       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
65623     } catch (std::out_of_range& e) {
65624       {
65625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65626       };
65627     } catch (std::exception& e) {
65628       {
65629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65630       };
65631     } catch (Dali::DaliException e) {
65632       {
65633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65634       };
65635     } catch (...) {
65636       {
65637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65638       };
65639     }
65640   }
65641
65642   jresult = (void *)result;
65643   return jresult;
65644 }
65645
65646
65647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
65648   void * jresult ;
65649   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65650   Dali::Toolkit::RadioButton *arg2 = 0 ;
65651   Dali::Toolkit::RadioButton *result = 0 ;
65652
65653   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65654   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
65655   if (!arg2) {
65656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65657     return 0;
65658   }
65659   {
65660     try {
65661       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
65662     } catch (std::out_of_range& e) {
65663       {
65664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65665       };
65666     } catch (std::exception& e) {
65667       {
65668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65669       };
65670     } catch (Dali::DaliException e) {
65671       {
65672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65673       };
65674     } catch (...) {
65675       {
65676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65677       };
65678     }
65679   }
65680
65681   jresult = (void *)result;
65682   return jresult;
65683 }
65684
65685
65686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
65687   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65688
65689   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65690   {
65691     try {
65692       delete arg1;
65693     } catch (std::out_of_range& e) {
65694       {
65695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65696       };
65697     } catch (std::exception& e) {
65698       {
65699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65700       };
65701     } catch (Dali::DaliException e) {
65702       {
65703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65704       };
65705     } catch (...) {
65706       {
65707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65708       };
65709     }
65710   }
65711
65712 }
65713
65714
65715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
65716   void * jresult ;
65717   Dali::Toolkit::RadioButton result;
65718
65719   {
65720     try {
65721       result = Dali::Toolkit::RadioButton::New();
65722     } catch (std::out_of_range& e) {
65723       {
65724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65725       };
65726     } catch (std::exception& e) {
65727       {
65728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65729       };
65730     } catch (Dali::DaliException e) {
65731       {
65732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65733       };
65734     } catch (...) {
65735       {
65736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65737       };
65738     }
65739   }
65740
65741   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65742   return jresult;
65743 }
65744
65745
65746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
65747   void * jresult ;
65748   std::string *arg1 = 0 ;
65749   Dali::Toolkit::RadioButton result;
65750
65751   if (!jarg1) {
65752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65753     return 0;
65754   }
65755   std::string arg1_str(jarg1);
65756   arg1 = &arg1_str;
65757   {
65758     try {
65759       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
65760     } catch (std::out_of_range& e) {
65761       {
65762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65763       };
65764     } catch (std::exception& e) {
65765       {
65766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65767       };
65768     } catch (Dali::DaliException e) {
65769       {
65770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65771       };
65772     } catch (...) {
65773       {
65774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65775       };
65776     }
65777   }
65778
65779   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65780
65781   //argout typemap for const std::string&
65782
65783   return jresult;
65784 }
65785
65786
65787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
65788   void * jresult ;
65789   Dali::BaseHandle arg1 ;
65790   Dali::BaseHandle *argp1 ;
65791   Dali::Toolkit::RadioButton result;
65792
65793   argp1 = (Dali::BaseHandle *)jarg1;
65794   if (!argp1) {
65795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65796     return 0;
65797   }
65798   arg1 = *argp1;
65799   {
65800     try {
65801       result = Dali::Toolkit::RadioButton::DownCast(arg1);
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 int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
65827   int jresult ;
65828   int result;
65829
65830   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
65831   jresult = (int)result;
65832   return jresult;
65833 }
65834
65835
65836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
65837   int jresult ;
65838   int result;
65839
65840   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
65841   jresult = (int)result;
65842   return jresult;
65843 }
65844
65845
65846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
65847   int jresult ;
65848   int result;
65849
65850   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
65851   jresult = (int)result;
65852   return jresult;
65853 }
65854
65855
65856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
65857   int jresult ;
65858   int result;
65859
65860   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
65861   jresult = (int)result;
65862   return jresult;
65863 }
65864
65865
65866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
65867   int jresult ;
65868   int result;
65869
65870   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
65871   jresult = (int)result;
65872   return jresult;
65873 }
65874
65875
65876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
65877   int jresult ;
65878   int result;
65879
65880   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
65881   jresult = (int)result;
65882   return jresult;
65883 }
65884
65885
65886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
65887   void * jresult ;
65888   Dali::Toolkit::FlexContainer::Property *result = 0 ;
65889
65890   {
65891     try {
65892       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
65893     } catch (std::out_of_range& e) {
65894       {
65895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65896       };
65897     } catch (std::exception& e) {
65898       {
65899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65900       };
65901     } catch (Dali::DaliException e) {
65902       {
65903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65904       };
65905     } catch (...) {
65906       {
65907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65908       };
65909     }
65910   }
65911
65912   jresult = (void *)result;
65913   return jresult;
65914 }
65915
65916
65917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
65918   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
65919
65920   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
65921   {
65922     try {
65923       delete arg1;
65924     } catch (std::out_of_range& e) {
65925       {
65926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65927       };
65928     } catch (std::exception& e) {
65929       {
65930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65931       };
65932     } catch (Dali::DaliException e) {
65933       {
65934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65935       };
65936     } catch (...) {
65937       {
65938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65939       };
65940     }
65941   }
65942
65943 }
65944
65945
65946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
65947   int jresult ;
65948   int result;
65949
65950   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
65951   jresult = (int)result;
65952   return jresult;
65953 }
65954
65955
65956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
65957   int jresult ;
65958   int result;
65959
65960   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
65961   jresult = (int)result;
65962   return jresult;
65963 }
65964
65965
65966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
65967   int jresult ;
65968   int result;
65969
65970   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
65971   jresult = (int)result;
65972   return jresult;
65973 }
65974
65975
65976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
65977   void * jresult ;
65978   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
65979
65980   {
65981     try {
65982       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
65983     } catch (std::out_of_range& e) {
65984       {
65985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65986       };
65987     } catch (std::exception& e) {
65988       {
65989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65990       };
65991     } catch (Dali::DaliException e) {
65992       {
65993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65994       };
65995     } catch (...) {
65996       {
65997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65998       };
65999     }
66000   }
66001
66002   jresult = (void *)result;
66003   return jresult;
66004 }
66005
66006
66007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
66008   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
66009
66010   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
66011   {
66012     try {
66013       delete arg1;
66014     } catch (std::out_of_range& e) {
66015       {
66016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66017       };
66018     } catch (std::exception& e) {
66019       {
66020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66021       };
66022     } catch (Dali::DaliException e) {
66023       {
66024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66025       };
66026     } catch (...) {
66027       {
66028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66029       };
66030     }
66031   }
66032
66033 }
66034
66035
66036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
66037   void * jresult ;
66038   Dali::Toolkit::FlexContainer *result = 0 ;
66039
66040   {
66041     try {
66042       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
66043     } catch (std::out_of_range& e) {
66044       {
66045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66046       };
66047     } catch (std::exception& e) {
66048       {
66049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66050       };
66051     } catch (Dali::DaliException e) {
66052       {
66053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66054       };
66055     } catch (...) {
66056       {
66057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66058       };
66059     }
66060   }
66061
66062   jresult = (void *)result;
66063   return jresult;
66064 }
66065
66066
66067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
66068   void * jresult ;
66069   Dali::Toolkit::FlexContainer *arg1 = 0 ;
66070   Dali::Toolkit::FlexContainer *result = 0 ;
66071
66072   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66073   if (!arg1) {
66074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66075     return 0;
66076   }
66077   {
66078     try {
66079       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
66080     } catch (std::out_of_range& e) {
66081       {
66082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66083       };
66084     } catch (std::exception& e) {
66085       {
66086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66087       };
66088     } catch (Dali::DaliException e) {
66089       {
66090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66091       };
66092     } catch (...) {
66093       {
66094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66095       };
66096     }
66097   }
66098
66099   jresult = (void *)result;
66100   return jresult;
66101 }
66102
66103
66104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
66105   void * jresult ;
66106   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66107   Dali::Toolkit::FlexContainer *arg2 = 0 ;
66108   Dali::Toolkit::FlexContainer *result = 0 ;
66109
66110   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66111   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
66112   if (!arg2) {
66113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66114     return 0;
66115   }
66116   {
66117     try {
66118       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
66119     } catch (std::out_of_range& e) {
66120       {
66121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66122       };
66123     } catch (std::exception& e) {
66124       {
66125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66126       };
66127     } catch (Dali::DaliException e) {
66128       {
66129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66130       };
66131     } catch (...) {
66132       {
66133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66134       };
66135     }
66136   }
66137
66138   jresult = (void *)result;
66139   return jresult;
66140 }
66141
66142
66143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
66144   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66145
66146   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66147   {
66148     try {
66149       delete arg1;
66150     } catch (std::out_of_range& e) {
66151       {
66152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66153       };
66154     } catch (std::exception& e) {
66155       {
66156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66157       };
66158     } catch (Dali::DaliException e) {
66159       {
66160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66161       };
66162     } catch (...) {
66163       {
66164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66165       };
66166     }
66167   }
66168
66169 }
66170
66171
66172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
66173   void * jresult ;
66174   Dali::Toolkit::FlexContainer result;
66175
66176   {
66177     try {
66178       result = Dali::Toolkit::FlexContainer::New();
66179     } catch (std::out_of_range& e) {
66180       {
66181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66182       };
66183     } catch (std::exception& e) {
66184       {
66185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66186       };
66187     } catch (Dali::DaliException e) {
66188       {
66189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66190       };
66191     } catch (...) {
66192       {
66193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66194       };
66195     }
66196   }
66197
66198   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66199   return jresult;
66200 }
66201
66202
66203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
66204   void * jresult ;
66205   Dali::BaseHandle arg1 ;
66206   Dali::BaseHandle *argp1 ;
66207   Dali::Toolkit::FlexContainer result;
66208
66209   argp1 = (Dali::BaseHandle *)jarg1;
66210   if (!argp1) {
66211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66212     return 0;
66213   }
66214   arg1 = *argp1;
66215   {
66216     try {
66217       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
66218     } catch (std::out_of_range& e) {
66219       {
66220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66221       };
66222     } catch (std::exception& e) {
66223       {
66224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66225       };
66226     } catch (Dali::DaliException e) {
66227       {
66228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66229       };
66230     } catch (...) {
66231       {
66232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66233       };
66234     }
66235   }
66236
66237   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66238   return jresult;
66239 }
66240
66241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
66242   int jresult ;
66243   int result;
66244
66245   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
66246   jresult = (int)result;
66247   return jresult;
66248 }
66249
66250
66251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
66252   int jresult ;
66253   int result;
66254
66255   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
66256   jresult = (int)result;
66257   return jresult;
66258 }
66259
66260
66261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
66262   int jresult ;
66263   int result;
66264
66265   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
66266   jresult = (int)result;
66267   return jresult;
66268 }
66269
66270
66271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
66272   void * jresult ;
66273   Dali::Toolkit::ImageView::Property *result = 0 ;
66274
66275   {
66276     try {
66277       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
66278     } catch (std::out_of_range& e) {
66279       {
66280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66281       };
66282     } catch (std::exception& e) {
66283       {
66284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66285       };
66286     } catch (Dali::DaliException e) {
66287       {
66288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66289       };
66290     } catch (...) {
66291       {
66292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66293       };
66294     }
66295   }
66296
66297   jresult = (void *)result;
66298   return jresult;
66299 }
66300
66301
66302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
66303   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
66304
66305   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
66306   {
66307     try {
66308       delete arg1;
66309     } catch (std::out_of_range& e) {
66310       {
66311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66312       };
66313     } catch (std::exception& e) {
66314       {
66315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66316       };
66317     } catch (Dali::DaliException e) {
66318       {
66319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66320       };
66321     } catch (...) {
66322       {
66323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66324       };
66325     }
66326   }
66327
66328 }
66329
66330
66331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
66332   void * jresult ;
66333   Dali::Toolkit::ImageView *result = 0 ;
66334
66335   {
66336     try {
66337       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
66338     } catch (std::out_of_range& e) {
66339       {
66340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66341       };
66342     } catch (std::exception& e) {
66343       {
66344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66345       };
66346     } catch (Dali::DaliException e) {
66347       {
66348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66349       };
66350     } catch (...) {
66351       {
66352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66353       };
66354     }
66355   }
66356
66357   jresult = (void *)result;
66358   return jresult;
66359 }
66360
66361
66362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
66363   void * jresult ;
66364   Dali::Toolkit::ImageView result;
66365
66366   {
66367     try {
66368       result = Dali::Toolkit::ImageView::New();
66369     } catch (std::out_of_range& e) {
66370       {
66371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66372       };
66373     } catch (std::exception& e) {
66374       {
66375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66376       };
66377     } catch (Dali::DaliException e) {
66378       {
66379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66380       };
66381     } catch (...) {
66382       {
66383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66384       };
66385     }
66386   }
66387
66388   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66389   return jresult;
66390 }
66391
66392
66393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
66394   void * jresult ;
66395   std::string *arg1 = 0 ;
66396   Dali::Toolkit::ImageView result;
66397
66398   if (!jarg1) {
66399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66400     return 0;
66401   }
66402   std::string arg1_str(jarg1);
66403   arg1 = &arg1_str;
66404   {
66405     try {
66406       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
66407     } catch (std::out_of_range& e) {
66408       {
66409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66410       };
66411     } catch (std::exception& e) {
66412       {
66413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66414       };
66415     } catch (Dali::DaliException e) {
66416       {
66417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66418       };
66419     } catch (...) {
66420       {
66421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66422       };
66423     }
66424   }
66425
66426   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66427
66428   //argout typemap for const std::string&
66429
66430   return jresult;
66431 }
66432
66433
66434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
66435   void * jresult ;
66436   std::string *arg1 = 0 ;
66437   Dali::ImageDimensions arg2 ;
66438   Dali::ImageDimensions *argp2 ;
66439   Dali::Toolkit::ImageView result;
66440
66441   if (!jarg1) {
66442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66443     return 0;
66444   }
66445   std::string arg1_str(jarg1);
66446   arg1 = &arg1_str;
66447   argp2 = (Dali::ImageDimensions *)jarg2;
66448   if (!argp2) {
66449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66450     return 0;
66451   }
66452   arg2 = *argp2;
66453   {
66454     try {
66455       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
66456     } catch (std::out_of_range& e) {
66457       {
66458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66459       };
66460     } catch (std::exception& e) {
66461       {
66462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66463       };
66464     } catch (Dali::DaliException e) {
66465       {
66466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66467       };
66468     } catch (...) {
66469       {
66470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66471       };
66472     }
66473   }
66474
66475   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66476
66477   //argout typemap for const std::string&
66478
66479   return jresult;
66480 }
66481
66482
66483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
66484   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66485
66486   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66487   {
66488     try {
66489       delete arg1;
66490     } catch (std::out_of_range& e) {
66491       {
66492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66493       };
66494     } catch (std::exception& e) {
66495       {
66496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66497       };
66498     } catch (Dali::DaliException e) {
66499       {
66500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66501       };
66502     } catch (...) {
66503       {
66504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66505       };
66506     }
66507   }
66508
66509 }
66510
66511
66512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
66513   void * jresult ;
66514   Dali::Toolkit::ImageView *arg1 = 0 ;
66515   Dali::Toolkit::ImageView *result = 0 ;
66516
66517   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66518   if (!arg1) {
66519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66520     return 0;
66521   }
66522   {
66523     try {
66524       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
66525     } catch (std::out_of_range& e) {
66526       {
66527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66528       };
66529     } catch (std::exception& e) {
66530       {
66531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66532       };
66533     } catch (Dali::DaliException e) {
66534       {
66535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66536       };
66537     } catch (...) {
66538       {
66539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66540       };
66541     }
66542   }
66543
66544   jresult = (void *)result;
66545   return jresult;
66546 }
66547
66548
66549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
66550   void * jresult ;
66551   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66552   Dali::Toolkit::ImageView *arg2 = 0 ;
66553   Dali::Toolkit::ImageView *result = 0 ;
66554
66555   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66556   arg2 = (Dali::Toolkit::ImageView *)jarg2;
66557   if (!arg2) {
66558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66559     return 0;
66560   }
66561   {
66562     try {
66563       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
66564     } catch (std::out_of_range& e) {
66565       {
66566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66567       };
66568     } catch (std::exception& e) {
66569       {
66570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66571       };
66572     } catch (Dali::DaliException e) {
66573       {
66574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66575       };
66576     } catch (...) {
66577       {
66578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66579       };
66580     }
66581   }
66582
66583   jresult = (void *)result;
66584   return jresult;
66585 }
66586
66587
66588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
66589   void * jresult ;
66590   Dali::BaseHandle arg1 ;
66591   Dali::BaseHandle *argp1 ;
66592   Dali::Toolkit::ImageView result;
66593
66594   argp1 = (Dali::BaseHandle *)jarg1;
66595   if (!argp1) {
66596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66597     return 0;
66598   }
66599   arg1 = *argp1;
66600   {
66601     try {
66602       result = Dali::Toolkit::ImageView::DownCast(arg1);
66603     } catch (std::out_of_range& e) {
66604       {
66605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66606       };
66607     } catch (std::exception& e) {
66608       {
66609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66610       };
66611     } catch (Dali::DaliException e) {
66612       {
66613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66614       };
66615     } catch (...) {
66616       {
66617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66618       };
66619     }
66620   }
66621
66622   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66623   return jresult;
66624 }
66625
66626
66627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
66628   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66629   std::string *arg2 = 0 ;
66630
66631   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66632   if (!jarg2) {
66633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66634     return ;
66635   }
66636   std::string arg2_str(jarg2);
66637   arg2 = &arg2_str;
66638   {
66639     try {
66640       (arg1)->SetImage((std::string const &)*arg2);
66641     } catch (std::out_of_range& e) {
66642       {
66643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66644       };
66645     } catch (std::exception& e) {
66646       {
66647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66648       };
66649     } catch (Dali::DaliException e) {
66650       {
66651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66652       };
66653     } catch (...) {
66654       {
66655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66656       };
66657     }
66658   }
66659
66660
66661   //argout typemap for const std::string&
66662
66663 }
66664
66665
66666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
66667   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66668   std::string *arg2 = 0 ;
66669   Dali::ImageDimensions arg3 ;
66670   Dali::ImageDimensions *argp3 ;
66671
66672   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66673   if (!jarg2) {
66674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66675     return ;
66676   }
66677   std::string arg2_str(jarg2);
66678   arg2 = &arg2_str;
66679   argp3 = (Dali::ImageDimensions *)jarg3;
66680   if (!argp3) {
66681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66682     return ;
66683   }
66684   arg3 = *argp3;
66685   {
66686     try {
66687       (arg1)->SetImage((std::string const &)*arg2,arg3);
66688     } catch (std::out_of_range& e) {
66689       {
66690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66691       };
66692     } catch (std::exception& e) {
66693       {
66694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66695       };
66696     } catch (Dali::DaliException e) {
66697       {
66698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66699       };
66700     } catch (...) {
66701       {
66702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66703       };
66704     }
66705   }
66706
66707
66708   //argout typemap for const std::string&
66709
66710 }
66711
66712
66713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
66714   int jresult ;
66715   int result;
66716
66717   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
66718   jresult = (int)result;
66719   return jresult;
66720 }
66721
66722
66723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
66724   int jresult ;
66725   int result;
66726
66727   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
66728   jresult = (int)result;
66729   return jresult;
66730 }
66731
66732
66733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
66734   int jresult ;
66735   int result;
66736
66737   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
66738   jresult = (int)result;
66739   return jresult;
66740 }
66741
66742
66743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
66744   int jresult ;
66745   int result;
66746
66747   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
66748   jresult = (int)result;
66749   return jresult;
66750 }
66751
66752
66753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
66754   int jresult ;
66755   int result;
66756
66757   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
66758   jresult = (int)result;
66759   return jresult;
66760 }
66761
66762
66763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
66764   int jresult ;
66765   int result;
66766
66767   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
66768   jresult = (int)result;
66769   return jresult;
66770 }
66771
66772
66773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
66774   int jresult ;
66775   int result;
66776
66777   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
66778   jresult = (int)result;
66779   return jresult;
66780 }
66781
66782
66783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
66784   int jresult ;
66785   int result;
66786
66787   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
66788   jresult = (int)result;
66789   return jresult;
66790 }
66791
66792
66793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
66794   void * jresult ;
66795   Dali::Toolkit::Model3dView::Property *result = 0 ;
66796
66797   {
66798     try {
66799       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
66800     } catch (std::out_of_range& e) {
66801       {
66802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66803       };
66804     } catch (std::exception& e) {
66805       {
66806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66807       };
66808     } catch (Dali::DaliException e) {
66809       {
66810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66811       };
66812     } catch (...) {
66813       {
66814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66815       };
66816     }
66817   }
66818
66819   jresult = (void *)result;
66820   return jresult;
66821 }
66822
66823
66824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
66825   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
66826
66827   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
66828   {
66829     try {
66830       delete arg1;
66831     } catch (std::out_of_range& e) {
66832       {
66833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66834       };
66835     } catch (std::exception& e) {
66836       {
66837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66838       };
66839     } catch (Dali::DaliException e) {
66840       {
66841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66842       };
66843     } catch (...) {
66844       {
66845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66846       };
66847     }
66848   }
66849
66850 }
66851
66852
66853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
66854   void * jresult ;
66855   Dali::Toolkit::Model3dView result;
66856
66857   {
66858     try {
66859       result = Dali::Toolkit::Model3dView::New();
66860     } catch (std::out_of_range& e) {
66861       {
66862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66863       };
66864     } catch (std::exception& e) {
66865       {
66866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66867       };
66868     } catch (Dali::DaliException e) {
66869       {
66870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66871       };
66872     } catch (...) {
66873       {
66874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66875       };
66876     }
66877   }
66878
66879   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66880   return jresult;
66881 }
66882
66883
66884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
66885   void * jresult ;
66886   std::string *arg1 = 0 ;
66887   std::string *arg2 = 0 ;
66888   std::string *arg3 = 0 ;
66889   Dali::Toolkit::Model3dView result;
66890
66891   if (!jarg1) {
66892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66893     return 0;
66894   }
66895   std::string arg1_str(jarg1);
66896   arg1 = &arg1_str;
66897   if (!jarg2) {
66898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66899     return 0;
66900   }
66901   std::string arg2_str(jarg2);
66902   arg2 = &arg2_str;
66903   if (!jarg3) {
66904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66905     return 0;
66906   }
66907   std::string arg3_str(jarg3);
66908   arg3 = &arg3_str;
66909   {
66910     try {
66911       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
66912     } catch (std::out_of_range& e) {
66913       {
66914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66915       };
66916     } catch (std::exception& e) {
66917       {
66918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66919       };
66920     } catch (Dali::DaliException e) {
66921       {
66922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66923       };
66924     } catch (...) {
66925       {
66926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66927       };
66928     }
66929   }
66930
66931   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66932
66933   //argout typemap for const std::string&
66934
66935
66936   //argout typemap for const std::string&
66937
66938
66939   //argout typemap for const std::string&
66940
66941   return jresult;
66942 }
66943
66944
66945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
66946   void * jresult ;
66947   Dali::Toolkit::Model3dView *result = 0 ;
66948
66949   {
66950     try {
66951       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
66952     } catch (std::out_of_range& e) {
66953       {
66954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66955       };
66956     } catch (std::exception& e) {
66957       {
66958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66959       };
66960     } catch (Dali::DaliException e) {
66961       {
66962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66963       };
66964     } catch (...) {
66965       {
66966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66967       };
66968     }
66969   }
66970
66971   jresult = (void *)result;
66972   return jresult;
66973 }
66974
66975
66976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
66977   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
66978
66979   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66980   {
66981     try {
66982       delete arg1;
66983     } catch (std::out_of_range& e) {
66984       {
66985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66986       };
66987     } catch (std::exception& e) {
66988       {
66989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66990       };
66991     } catch (Dali::DaliException e) {
66992       {
66993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66994       };
66995     } catch (...) {
66996       {
66997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66998       };
66999     }
67000   }
67001
67002 }
67003
67004
67005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
67006   void * jresult ;
67007   Dali::Toolkit::Model3dView *arg1 = 0 ;
67008   Dali::Toolkit::Model3dView *result = 0 ;
67009
67010   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67011   if (!arg1) {
67012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67013     return 0;
67014   }
67015   {
67016     try {
67017       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
67018     } catch (std::out_of_range& e) {
67019       {
67020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67021       };
67022     } catch (std::exception& e) {
67023       {
67024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67025       };
67026     } catch (Dali::DaliException e) {
67027       {
67028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67029       };
67030     } catch (...) {
67031       {
67032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67033       };
67034     }
67035   }
67036
67037   jresult = (void *)result;
67038   return jresult;
67039 }
67040
67041
67042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
67043   void * jresult ;
67044   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67045   Dali::Toolkit::Model3dView *arg2 = 0 ;
67046   Dali::Toolkit::Model3dView *result = 0 ;
67047
67048   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67049   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
67050   if (!arg2) {
67051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67052     return 0;
67053   }
67054   {
67055     try {
67056       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
67057     } catch (std::out_of_range& e) {
67058       {
67059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67060       };
67061     } catch (std::exception& e) {
67062       {
67063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67064       };
67065     } catch (Dali::DaliException e) {
67066       {
67067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67068       };
67069     } catch (...) {
67070       {
67071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67072       };
67073     }
67074   }
67075
67076   jresult = (void *)result;
67077   return jresult;
67078 }
67079
67080
67081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
67082   void * jresult ;
67083   Dali::BaseHandle arg1 ;
67084   Dali::BaseHandle *argp1 ;
67085   Dali::Toolkit::Model3dView result;
67086
67087   argp1 = (Dali::BaseHandle *)jarg1;
67088   if (!argp1) {
67089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67090     return 0;
67091   }
67092   arg1 = *argp1;
67093   {
67094     try {
67095       result = Dali::Toolkit::Model3dView::DownCast(arg1);
67096     } catch (std::out_of_range& e) {
67097       {
67098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67099       };
67100     } catch (std::exception& e) {
67101       {
67102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67103       };
67104     } catch (Dali::DaliException e) {
67105       {
67106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67107       };
67108     } catch (...) {
67109       {
67110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67111       };
67112     }
67113   }
67114
67115   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67116   return jresult;
67117 }
67118
67119
67120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
67121   int jresult ;
67122   int result;
67123
67124   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
67125   jresult = (int)result;
67126   return jresult;
67127 }
67128
67129
67130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
67131   int jresult ;
67132   int result;
67133
67134   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
67135   jresult = (int)result;
67136   return jresult;
67137 }
67138
67139
67140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
67141   int jresult ;
67142   int result;
67143
67144   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
67145   jresult = (int)result;
67146   return jresult;
67147 }
67148
67149
67150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
67151   int jresult ;
67152   int result;
67153
67154   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
67155   jresult = (int)result;
67156   return jresult;
67157 }
67158
67159
67160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
67161   int jresult ;
67162   int result;
67163
67164   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
67165   jresult = (int)result;
67166   return jresult;
67167 }
67168
67169
67170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
67171   int jresult ;
67172   int result;
67173
67174   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
67175   jresult = (int)result;
67176   return jresult;
67177 }
67178
67179
67180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
67181   int jresult ;
67182   int result;
67183
67184   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
67185   jresult = (int)result;
67186   return jresult;
67187 }
67188
67189
67190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
67191   int jresult ;
67192   int result;
67193
67194   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
67195   jresult = (int)result;
67196   return jresult;
67197 }
67198
67199
67200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
67201   int jresult ;
67202   int result;
67203
67204   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
67205   jresult = (int)result;
67206   return jresult;
67207 }
67208
67209
67210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
67211   void * jresult ;
67212   Dali::Toolkit::ScrollBar::Property *result = 0 ;
67213
67214   {
67215     try {
67216       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
67217     } catch (std::out_of_range& e) {
67218       {
67219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67220       };
67221     } catch (std::exception& e) {
67222       {
67223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67224       };
67225     } catch (Dali::DaliException e) {
67226       {
67227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67228       };
67229     } catch (...) {
67230       {
67231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67232       };
67233     }
67234   }
67235
67236   jresult = (void *)result;
67237   return jresult;
67238 }
67239
67240
67241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
67242   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
67243
67244   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
67245   {
67246     try {
67247       delete arg1;
67248     } catch (std::out_of_range& e) {
67249       {
67250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67251       };
67252     } catch (std::exception& e) {
67253       {
67254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67255       };
67256     } catch (Dali::DaliException e) {
67257       {
67258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67259       };
67260     } catch (...) {
67261       {
67262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67263       };
67264     }
67265   }
67266
67267 }
67268
67269
67270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
67271   void * jresult ;
67272   Dali::Toolkit::ScrollBar *result = 0 ;
67273
67274   {
67275     try {
67276       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
67277     } catch (std::out_of_range& e) {
67278       {
67279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67280       };
67281     } catch (std::exception& e) {
67282       {
67283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67284       };
67285     } catch (Dali::DaliException e) {
67286       {
67287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67288       };
67289     } catch (...) {
67290       {
67291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67292       };
67293     }
67294   }
67295
67296   jresult = (void *)result;
67297   return jresult;
67298 }
67299
67300
67301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
67302   void * jresult ;
67303   Dali::Toolkit::ScrollBar *arg1 = 0 ;
67304   Dali::Toolkit::ScrollBar *result = 0 ;
67305
67306   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67307   if (!arg1) {
67308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67309     return 0;
67310   }
67311   {
67312     try {
67313       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
67314     } catch (std::out_of_range& e) {
67315       {
67316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67317       };
67318     } catch (std::exception& e) {
67319       {
67320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67321       };
67322     } catch (Dali::DaliException e) {
67323       {
67324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67325       };
67326     } catch (...) {
67327       {
67328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67329       };
67330     }
67331   }
67332
67333   jresult = (void *)result;
67334   return jresult;
67335 }
67336
67337
67338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
67339   void * jresult ;
67340   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67341   Dali::Toolkit::ScrollBar *arg2 = 0 ;
67342   Dali::Toolkit::ScrollBar *result = 0 ;
67343
67344   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67345   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
67346   if (!arg2) {
67347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67348     return 0;
67349   }
67350   {
67351     try {
67352       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
67353     } catch (std::out_of_range& e) {
67354       {
67355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67356       };
67357     } catch (std::exception& e) {
67358       {
67359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67360       };
67361     } catch (Dali::DaliException e) {
67362       {
67363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67364       };
67365     } catch (...) {
67366       {
67367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67368       };
67369     }
67370   }
67371
67372   jresult = (void *)result;
67373   return jresult;
67374 }
67375
67376
67377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
67378   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67379
67380   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67381   {
67382     try {
67383       delete arg1;
67384     } catch (std::out_of_range& e) {
67385       {
67386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67387       };
67388     } catch (std::exception& e) {
67389       {
67390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67391       };
67392     } catch (Dali::DaliException e) {
67393       {
67394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67395       };
67396     } catch (...) {
67397       {
67398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67399       };
67400     }
67401   }
67402
67403 }
67404
67405
67406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
67407   void * jresult ;
67408   Dali::Toolkit::ScrollBar::Direction arg1 ;
67409   Dali::Toolkit::ScrollBar result;
67410
67411   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
67412   {
67413     try {
67414       result = Dali::Toolkit::ScrollBar::New(arg1);
67415     } catch (std::out_of_range& e) {
67416       {
67417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67418       };
67419     } catch (std::exception& e) {
67420       {
67421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67422       };
67423     } catch (Dali::DaliException e) {
67424       {
67425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67426       };
67427     } catch (...) {
67428       {
67429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67430       };
67431     }
67432   }
67433
67434   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67435   return jresult;
67436 }
67437
67438
67439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
67440   void * jresult ;
67441   Dali::Toolkit::ScrollBar result;
67442
67443   {
67444     try {
67445       result = Dali::Toolkit::ScrollBar::New();
67446     } catch (std::out_of_range& e) {
67447       {
67448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67449       };
67450     } catch (std::exception& e) {
67451       {
67452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67453       };
67454     } catch (Dali::DaliException e) {
67455       {
67456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67457       };
67458     } catch (...) {
67459       {
67460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67461       };
67462     }
67463   }
67464
67465   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67466   return jresult;
67467 }
67468
67469
67470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
67471   void * jresult ;
67472   Dali::BaseHandle arg1 ;
67473   Dali::BaseHandle *argp1 ;
67474   Dali::Toolkit::ScrollBar result;
67475
67476   argp1 = (Dali::BaseHandle *)jarg1;
67477   if (!argp1) {
67478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67479     return 0;
67480   }
67481   arg1 = *argp1;
67482   {
67483     try {
67484       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
67485     } catch (std::out_of_range& e) {
67486       {
67487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67488       };
67489     } catch (std::exception& e) {
67490       {
67491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67492       };
67493     } catch (Dali::DaliException e) {
67494       {
67495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67496       };
67497     } catch (...) {
67498       {
67499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67500       };
67501     }
67502   }
67503
67504   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67505   return jresult;
67506 }
67507
67508
67509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
67510   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67511   Dali::Handle arg2 ;
67512   Dali::Property::Index arg3 ;
67513   Dali::Property::Index arg4 ;
67514   Dali::Property::Index arg5 ;
67515   Dali::Property::Index arg6 ;
67516   Dali::Handle *argp2 ;
67517
67518   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67519   argp2 = (Dali::Handle *)jarg2;
67520   if (!argp2) {
67521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
67522     return ;
67523   }
67524   arg2 = *argp2;
67525   arg3 = (Dali::Property::Index)jarg3;
67526   arg4 = (Dali::Property::Index)jarg4;
67527   arg5 = (Dali::Property::Index)jarg5;
67528   arg6 = (Dali::Property::Index)jarg6;
67529   {
67530     try {
67531       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
67532     } catch (std::out_of_range& e) {
67533       {
67534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67535       };
67536     } catch (std::exception& e) {
67537       {
67538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67539       };
67540     } catch (Dali::DaliException e) {
67541       {
67542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67543       };
67544     } catch (...) {
67545       {
67546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67547       };
67548     }
67549   }
67550
67551 }
67552
67553
67554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
67555   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67556   Dali::Actor arg2 ;
67557   Dali::Actor *argp2 ;
67558
67559   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67560   argp2 = (Dali::Actor *)jarg2;
67561   if (!argp2) {
67562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67563     return ;
67564   }
67565   arg2 = *argp2;
67566   {
67567     try {
67568       (arg1)->SetScrollIndicator(arg2);
67569     } catch (std::out_of_range& e) {
67570       {
67571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67572       };
67573     } catch (std::exception& e) {
67574       {
67575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67576       };
67577     } catch (Dali::DaliException e) {
67578       {
67579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67580       };
67581     } catch (...) {
67582       {
67583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67584       };
67585     }
67586   }
67587
67588 }
67589
67590
67591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
67592   void * jresult ;
67593   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67594   Dali::Actor result;
67595
67596   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67597   {
67598     try {
67599       result = (arg1)->GetScrollIndicator();
67600     } catch (std::out_of_range& e) {
67601       {
67602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67603       };
67604     } catch (std::exception& e) {
67605       {
67606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67607       };
67608     } catch (Dali::DaliException e) {
67609       {
67610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67611       };
67612     } catch (...) {
67613       {
67614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67615       };
67616     }
67617   }
67618
67619   jresult = new Dali::Actor((const Dali::Actor &)result);
67620   return jresult;
67621 }
67622
67623
67624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
67625   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67626   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
67627
67628   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67629   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
67630   if (!arg2) {
67631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
67632     return ;
67633   }
67634   {
67635     try {
67636       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
67637     } catch (std::out_of_range& e) {
67638       {
67639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67640       };
67641     } catch (std::exception& e) {
67642       {
67643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67644       };
67645     } catch (Dali::DaliException e) {
67646       {
67647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67648       };
67649     } catch (...) {
67650       {
67651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67652       };
67653     }
67654   }
67655
67656 }
67657
67658
67659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
67660   void * jresult ;
67661   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67662
67663   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67664   {
67665     try {
67666       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()));
67667     } catch (std::out_of_range& e) {
67668       {
67669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67670       };
67671     } catch (std::exception& e) {
67672       {
67673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67674       };
67675     } catch (...) {
67676       {
67677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67678       };
67679     }
67680   }
67681   return jresult;
67682 }
67683
67684
67685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
67686   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67687   Dali::Toolkit::ScrollBar::Direction arg2 ;
67688
67689   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67690   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
67691   {
67692     try {
67693       (arg1)->SetScrollDirection(arg2);
67694     } catch (std::out_of_range& e) {
67695       {
67696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67697       };
67698     } catch (std::exception& e) {
67699       {
67700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67701       };
67702     } catch (Dali::DaliException e) {
67703       {
67704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67705       };
67706     } catch (...) {
67707       {
67708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67709       };
67710     }
67711   }
67712
67713 }
67714
67715
67716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
67717   int jresult ;
67718   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67719   Dali::Toolkit::ScrollBar::Direction result;
67720
67721   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67722   {
67723     try {
67724       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
67725     } catch (std::out_of_range& e) {
67726       {
67727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67728       };
67729     } catch (std::exception& e) {
67730       {
67731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67732       };
67733     } catch (Dali::DaliException e) {
67734       {
67735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67736       };
67737     } catch (...) {
67738       {
67739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67740       };
67741     }
67742   }
67743
67744   jresult = (int)result;
67745   return jresult;
67746 }
67747
67748
67749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
67750   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67751   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
67752
67753   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67754   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
67755   {
67756     try {
67757       (arg1)->SetIndicatorHeightPolicy(arg2);
67758     } catch (std::out_of_range& e) {
67759       {
67760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67761       };
67762     } catch (std::exception& e) {
67763       {
67764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67765       };
67766     } catch (Dali::DaliException e) {
67767       {
67768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67769       };
67770     } catch (...) {
67771       {
67772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67773       };
67774     }
67775   }
67776
67777 }
67778
67779
67780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
67781   int jresult ;
67782   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67783   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
67784
67785   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67786   {
67787     try {
67788       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
67789     } catch (std::out_of_range& e) {
67790       {
67791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67792       };
67793     } catch (std::exception& e) {
67794       {
67795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67796       };
67797     } catch (Dali::DaliException e) {
67798       {
67799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67800       };
67801     } catch (...) {
67802       {
67803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67804       };
67805     }
67806   }
67807
67808   jresult = (int)result;
67809   return jresult;
67810 }
67811
67812
67813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
67814   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67815   float arg2 ;
67816
67817   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67818   arg2 = (float)jarg2;
67819   {
67820     try {
67821       (arg1)->SetIndicatorFixedHeight(arg2);
67822     } catch (std::out_of_range& e) {
67823       {
67824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67825       };
67826     } catch (std::exception& e) {
67827       {
67828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67829       };
67830     } catch (Dali::DaliException e) {
67831       {
67832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67833       };
67834     } catch (...) {
67835       {
67836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67837       };
67838     }
67839   }
67840
67841 }
67842
67843
67844 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
67845   float jresult ;
67846   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67847   float result;
67848
67849   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67850   {
67851     try {
67852       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
67853     } catch (std::out_of_range& e) {
67854       {
67855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67856       };
67857     } catch (std::exception& e) {
67858       {
67859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67860       };
67861     } catch (Dali::DaliException e) {
67862       {
67863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67864       };
67865     } catch (...) {
67866       {
67867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67868       };
67869     }
67870   }
67871
67872   jresult = result;
67873   return jresult;
67874 }
67875
67876
67877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
67878   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67879   float arg2 ;
67880
67881   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67882   arg2 = (float)jarg2;
67883   {
67884     try {
67885       (arg1)->SetIndicatorShowDuration(arg2);
67886     } catch (std::out_of_range& e) {
67887       {
67888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67889       };
67890     } catch (std::exception& e) {
67891       {
67892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67893       };
67894     } catch (Dali::DaliException e) {
67895       {
67896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67897       };
67898     } catch (...) {
67899       {
67900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67901       };
67902     }
67903   }
67904
67905 }
67906
67907
67908 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
67909   float jresult ;
67910   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67911   float result;
67912
67913   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67914   {
67915     try {
67916       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
67917     } catch (std::out_of_range& e) {
67918       {
67919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67920       };
67921     } catch (std::exception& e) {
67922       {
67923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67924       };
67925     } catch (Dali::DaliException e) {
67926       {
67927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67928       };
67929     } catch (...) {
67930       {
67931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67932       };
67933     }
67934   }
67935
67936   jresult = result;
67937   return jresult;
67938 }
67939
67940
67941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
67942   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67943   float arg2 ;
67944
67945   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67946   arg2 = (float)jarg2;
67947   {
67948     try {
67949       (arg1)->SetIndicatorHideDuration(arg2);
67950     } catch (std::out_of_range& e) {
67951       {
67952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67953       };
67954     } catch (std::exception& e) {
67955       {
67956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67957       };
67958     } catch (Dali::DaliException e) {
67959       {
67960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67961       };
67962     } catch (...) {
67963       {
67964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67965       };
67966     }
67967   }
67968
67969 }
67970
67971
67972 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
67973   float jresult ;
67974   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67975   float result;
67976
67977   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67978   {
67979     try {
67980       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
67981     } catch (std::out_of_range& e) {
67982       {
67983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67984       };
67985     } catch (std::exception& e) {
67986       {
67987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67988       };
67989     } catch (Dali::DaliException e) {
67990       {
67991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67992       };
67993     } catch (...) {
67994       {
67995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67996       };
67997     }
67998   }
67999
68000   jresult = result;
68001   return jresult;
68002 }
68003
68004
68005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
68006   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68007
68008   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68009   {
68010     try {
68011       (arg1)->ShowIndicator();
68012     } catch (std::out_of_range& e) {
68013       {
68014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68015       };
68016     } catch (std::exception& e) {
68017       {
68018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68019       };
68020     } catch (Dali::DaliException e) {
68021       {
68022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68023       };
68024     } catch (...) {
68025       {
68026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68027       };
68028     }
68029   }
68030
68031 }
68032
68033
68034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
68035   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68036
68037   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68038   {
68039     try {
68040       (arg1)->HideIndicator();
68041     } catch (std::out_of_range& e) {
68042       {
68043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68044       };
68045     } catch (std::exception& e) {
68046       {
68047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68048       };
68049     } catch (Dali::DaliException e) {
68050       {
68051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68052       };
68053     } catch (...) {
68054       {
68055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68056       };
68057     }
68058   }
68059
68060 }
68061
68062
68063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
68064   void * jresult ;
68065   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68066   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
68067
68068   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68069   {
68070     try {
68071       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
68072     } catch (std::out_of_range& e) {
68073       {
68074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68075       };
68076     } catch (std::exception& e) {
68077       {
68078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68079       };
68080     } catch (Dali::DaliException e) {
68081       {
68082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68083       };
68084     } catch (...) {
68085       {
68086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68087       };
68088     }
68089   }
68090
68091   jresult = (void *)result;
68092   return jresult;
68093 }
68094
68095
68096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
68097   void * jresult ;
68098   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68099   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
68100
68101   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68102   {
68103     try {
68104       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
68105     } catch (std::out_of_range& e) {
68106       {
68107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68108       };
68109     } catch (std::exception& e) {
68110       {
68111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68112       };
68113     } catch (Dali::DaliException e) {
68114       {
68115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68116       };
68117     } catch (...) {
68118       {
68119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68120       };
68121     }
68122   }
68123
68124   jresult = (void *)result;
68125   return jresult;
68126 }
68127
68128
68129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
68130   int jresult ;
68131   int result;
68132
68133   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
68134   jresult = (int)result;
68135   return jresult;
68136 }
68137
68138
68139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
68140   int jresult ;
68141   int result;
68142
68143   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
68144   jresult = (int)result;
68145   return jresult;
68146 }
68147
68148
68149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
68150   int jresult ;
68151   int result;
68152
68153   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
68154   jresult = (int)result;
68155   return jresult;
68156 }
68157
68158
68159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
68160   int jresult ;
68161   int result;
68162
68163   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
68164   jresult = (int)result;
68165   return jresult;
68166 }
68167
68168
68169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
68170   int jresult ;
68171   int result;
68172
68173   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
68174   jresult = (int)result;
68175   return jresult;
68176 }
68177
68178
68179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
68180   int jresult ;
68181   int result;
68182
68183   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
68184   jresult = (int)result;
68185   return jresult;
68186 }
68187
68188
68189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
68190   int jresult ;
68191   int result;
68192
68193   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
68194   jresult = (int)result;
68195   return jresult;
68196 }
68197
68198
68199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
68200   int jresult ;
68201   int result;
68202
68203   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
68204   jresult = (int)result;
68205   return jresult;
68206 }
68207
68208
68209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
68210   int jresult ;
68211   int result;
68212
68213   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
68214   jresult = (int)result;
68215   return jresult;
68216 }
68217
68218
68219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
68220   int jresult ;
68221   int result;
68222
68223   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
68224   jresult = (int)result;
68225   return jresult;
68226 }
68227
68228
68229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
68230   int jresult ;
68231   int result;
68232
68233   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
68234   jresult = (int)result;
68235   return jresult;
68236 }
68237
68238
68239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
68240   int jresult ;
68241   int result;
68242
68243   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
68244   jresult = (int)result;
68245   return jresult;
68246 }
68247
68248
68249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
68250   int jresult ;
68251   int result;
68252
68253   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
68254   jresult = (int)result;
68255   return jresult;
68256 }
68257
68258
68259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
68260   int jresult ;
68261   int result;
68262
68263   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
68264   jresult = (int)result;
68265   return jresult;
68266 }
68267
68268
68269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
68270   void * jresult ;
68271   Dali::Toolkit::Scrollable::Property *result = 0 ;
68272
68273   {
68274     try {
68275       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
68276     } catch (std::out_of_range& e) {
68277       {
68278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68279       };
68280     } catch (std::exception& e) {
68281       {
68282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68283       };
68284     } catch (Dali::DaliException e) {
68285       {
68286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68287       };
68288     } catch (...) {
68289       {
68290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68291       };
68292     }
68293   }
68294
68295   jresult = (void *)result;
68296   return jresult;
68297 }
68298
68299
68300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
68301   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
68302
68303   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
68304   {
68305     try {
68306       delete arg1;
68307     } catch (std::out_of_range& e) {
68308       {
68309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68310       };
68311     } catch (std::exception& e) {
68312       {
68313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68314       };
68315     } catch (Dali::DaliException e) {
68316       {
68317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68318       };
68319     } catch (...) {
68320       {
68321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68322       };
68323     }
68324   }
68325
68326 }
68327
68328
68329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
68330   void * jresult ;
68331   Dali::Toolkit::Scrollable *result = 0 ;
68332
68333   {
68334     try {
68335       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
68336     } catch (std::out_of_range& e) {
68337       {
68338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68339       };
68340     } catch (std::exception& e) {
68341       {
68342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68343       };
68344     } catch (Dali::DaliException e) {
68345       {
68346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68347       };
68348     } catch (...) {
68349       {
68350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68351       };
68352     }
68353   }
68354
68355   jresult = (void *)result;
68356   return jresult;
68357 }
68358
68359
68360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
68361   void * jresult ;
68362   Dali::Toolkit::Scrollable *arg1 = 0 ;
68363   Dali::Toolkit::Scrollable *result = 0 ;
68364
68365   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68366   if (!arg1) {
68367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68368     return 0;
68369   }
68370   {
68371     try {
68372       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
68373     } catch (std::out_of_range& e) {
68374       {
68375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68376       };
68377     } catch (std::exception& e) {
68378       {
68379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68380       };
68381     } catch (Dali::DaliException e) {
68382       {
68383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68384       };
68385     } catch (...) {
68386       {
68387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68388       };
68389     }
68390   }
68391
68392   jresult = (void *)result;
68393   return jresult;
68394 }
68395
68396
68397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
68398   void * jresult ;
68399   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68400   Dali::Toolkit::Scrollable *arg2 = 0 ;
68401   Dali::Toolkit::Scrollable *result = 0 ;
68402
68403   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68404   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
68405   if (!arg2) {
68406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68407     return 0;
68408   }
68409   {
68410     try {
68411       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
68412     } catch (std::out_of_range& e) {
68413       {
68414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68415       };
68416     } catch (std::exception& e) {
68417       {
68418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68419       };
68420     } catch (Dali::DaliException e) {
68421       {
68422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68423       };
68424     } catch (...) {
68425       {
68426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68427       };
68428     }
68429   }
68430
68431   jresult = (void *)result;
68432   return jresult;
68433 }
68434
68435
68436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
68437   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68438
68439   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68440   {
68441     try {
68442       delete arg1;
68443     } catch (std::out_of_range& e) {
68444       {
68445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68446       };
68447     } catch (std::exception& e) {
68448       {
68449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68450       };
68451     } catch (Dali::DaliException e) {
68452       {
68453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68454       };
68455     } catch (...) {
68456       {
68457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68458       };
68459     }
68460   }
68461
68462 }
68463
68464
68465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
68466   void * jresult ;
68467   Dali::BaseHandle arg1 ;
68468   Dali::BaseHandle *argp1 ;
68469   Dali::Toolkit::Scrollable result;
68470
68471   argp1 = (Dali::BaseHandle *)jarg1;
68472   if (!argp1) {
68473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68474     return 0;
68475   }
68476   arg1 = *argp1;
68477   {
68478     try {
68479       result = Dali::Toolkit::Scrollable::DownCast(arg1);
68480     } catch (std::out_of_range& e) {
68481       {
68482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68483       };
68484     } catch (std::exception& e) {
68485       {
68486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68487       };
68488     } catch (Dali::DaliException e) {
68489       {
68490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68491       };
68492     } catch (...) {
68493       {
68494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68495       };
68496     }
68497   }
68498
68499   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
68500   return jresult;
68501 }
68502
68503
68504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
68505   unsigned int jresult ;
68506   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68507   bool result;
68508
68509   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68510   {
68511     try {
68512       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
68513     } catch (std::out_of_range& e) {
68514       {
68515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68516       };
68517     } catch (std::exception& e) {
68518       {
68519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68520       };
68521     } catch (Dali::DaliException e) {
68522       {
68523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68524       };
68525     } catch (...) {
68526       {
68527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68528       };
68529     }
68530   }
68531
68532   jresult = result;
68533   return jresult;
68534 }
68535
68536
68537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
68538   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68539   bool arg2 ;
68540
68541   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68542   arg2 = jarg2 ? true : false;
68543   {
68544     try {
68545       (arg1)->SetOvershootEnabled(arg2);
68546     } catch (std::out_of_range& e) {
68547       {
68548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68549       };
68550     } catch (std::exception& e) {
68551       {
68552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68553       };
68554     } catch (Dali::DaliException e) {
68555       {
68556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68557       };
68558     } catch (...) {
68559       {
68560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68561       };
68562     }
68563   }
68564
68565 }
68566
68567
68568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
68569   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68570   Dali::Vector4 *arg2 = 0 ;
68571
68572   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68573   arg2 = (Dali::Vector4 *)jarg2;
68574   if (!arg2) {
68575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68576     return ;
68577   }
68578   {
68579     try {
68580       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
68581     } catch (std::out_of_range& e) {
68582       {
68583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68584       };
68585     } catch (std::exception& e) {
68586       {
68587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68588       };
68589     } catch (Dali::DaliException e) {
68590       {
68591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68592       };
68593     } catch (...) {
68594       {
68595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68596       };
68597     }
68598   }
68599
68600 }
68601
68602
68603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
68604   void * jresult ;
68605   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68606   Dali::Vector4 result;
68607
68608   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68609   {
68610     try {
68611       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
68612     } catch (std::out_of_range& e) {
68613       {
68614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68615       };
68616     } catch (std::exception& e) {
68617       {
68618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68619       };
68620     } catch (Dali::DaliException e) {
68621       {
68622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68623       };
68624     } catch (...) {
68625       {
68626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68627       };
68628     }
68629   }
68630
68631   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68632   return jresult;
68633 }
68634
68635
68636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
68637   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68638   float arg2 ;
68639
68640   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68641   arg2 = (float)jarg2;
68642   {
68643     try {
68644       (arg1)->SetOvershootAnimationSpeed(arg2);
68645     } catch (std::out_of_range& e) {
68646       {
68647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68648       };
68649     } catch (std::exception& e) {
68650       {
68651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68652       };
68653     } catch (Dali::DaliException e) {
68654       {
68655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68656       };
68657     } catch (...) {
68658       {
68659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68660       };
68661     }
68662   }
68663
68664 }
68665
68666
68667 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
68668   float jresult ;
68669   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68670   float result;
68671
68672   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68673   {
68674     try {
68675       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
68676     } catch (std::out_of_range& e) {
68677       {
68678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68679       };
68680     } catch (std::exception& e) {
68681       {
68682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68683       };
68684     } catch (Dali::DaliException e) {
68685       {
68686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68687       };
68688     } catch (...) {
68689       {
68690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68691       };
68692     }
68693   }
68694
68695   jresult = result;
68696   return jresult;
68697 }
68698
68699
68700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
68701   void * jresult ;
68702   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68703   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
68704
68705   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68706   {
68707     try {
68708       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
68709     } catch (std::out_of_range& e) {
68710       {
68711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68712       };
68713     } catch (std::exception& e) {
68714       {
68715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68716       };
68717     } catch (Dali::DaliException e) {
68718       {
68719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68720       };
68721     } catch (...) {
68722       {
68723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68724       };
68725     }
68726   }
68727
68728   jresult = (void *)result;
68729   return jresult;
68730 }
68731
68732
68733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
68734   void * jresult ;
68735   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68736   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
68737
68738   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68739   {
68740     try {
68741       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
68742     } catch (std::out_of_range& e) {
68743       {
68744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68745       };
68746     } catch (std::exception& e) {
68747       {
68748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68749       };
68750     } catch (Dali::DaliException e) {
68751       {
68752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68753       };
68754     } catch (...) {
68755       {
68756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68757       };
68758     }
68759   }
68760
68761   jresult = (void *)result;
68762   return jresult;
68763 }
68764
68765
68766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
68767   void * jresult ;
68768   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68769   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
68770
68771   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68772   {
68773     try {
68774       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
68775     } catch (std::out_of_range& e) {
68776       {
68777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68778       };
68779     } catch (std::exception& e) {
68780       {
68781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68782       };
68783     } catch (Dali::DaliException e) {
68784       {
68785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68786       };
68787     } catch (...) {
68788       {
68789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68790       };
68791     }
68792   }
68793
68794   jresult = (void *)result;
68795   return jresult;
68796 }
68797
68798
68799 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
68800   unsigned int jresult ;
68801   Dali::Toolkit::ControlOrientation::Type arg1 ;
68802   bool result;
68803
68804   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68805   {
68806     try {
68807       result = (bool)Dali::Toolkit::IsVertical(arg1);
68808     } catch (std::out_of_range& e) {
68809       {
68810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68811       };
68812     } catch (std::exception& e) {
68813       {
68814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68815       };
68816     } catch (Dali::DaliException e) {
68817       {
68818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68819       };
68820     } catch (...) {
68821       {
68822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68823       };
68824     }
68825   }
68826
68827   jresult = result;
68828   return jresult;
68829 }
68830
68831
68832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
68833   unsigned int jresult ;
68834   Dali::Toolkit::ControlOrientation::Type arg1 ;
68835   bool result;
68836
68837   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68838   {
68839     try {
68840       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
68841     } catch (std::out_of_range& e) {
68842       {
68843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68844       };
68845     } catch (std::exception& e) {
68846       {
68847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68848       };
68849     } catch (Dali::DaliException e) {
68850       {
68851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68852       };
68853     } catch (...) {
68854       {
68855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68856       };
68857     }
68858   }
68859
68860   jresult = result;
68861   return jresult;
68862 }
68863
68864
68865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
68866   void * jresult ;
68867   unsigned int arg1 ;
68868   unsigned int arg2 ;
68869   Dali::Toolkit::ItemRange *result = 0 ;
68870
68871   arg1 = (unsigned int)jarg1;
68872   arg2 = (unsigned int)jarg2;
68873   {
68874     try {
68875       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
68876     } catch (std::out_of_range& e) {
68877       {
68878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68879       };
68880     } catch (std::exception& e) {
68881       {
68882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68883       };
68884     } catch (Dali::DaliException e) {
68885       {
68886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68887       };
68888     } catch (...) {
68889       {
68890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68891       };
68892     }
68893   }
68894
68895   jresult = (void *)result;
68896   return jresult;
68897 }
68898
68899
68900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
68901   void * jresult ;
68902   Dali::Toolkit::ItemRange *arg1 = 0 ;
68903   Dali::Toolkit::ItemRange *result = 0 ;
68904
68905   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68906   if (!arg1) {
68907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68908     return 0;
68909   }
68910   {
68911     try {
68912       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
68913     } catch (std::out_of_range& e) {
68914       {
68915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68916       };
68917     } catch (std::exception& e) {
68918       {
68919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68920       };
68921     } catch (Dali::DaliException e) {
68922       {
68923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68924       };
68925     } catch (...) {
68926       {
68927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68928       };
68929     }
68930   }
68931
68932   jresult = (void *)result;
68933   return jresult;
68934 }
68935
68936
68937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
68938   void * jresult ;
68939   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68940   Dali::Toolkit::ItemRange *arg2 = 0 ;
68941   Dali::Toolkit::ItemRange *result = 0 ;
68942
68943   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68944   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68945   if (!arg2) {
68946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68947     return 0;
68948   }
68949   {
68950     try {
68951       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
68952     } catch (std::out_of_range& e) {
68953       {
68954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68955       };
68956     } catch (std::exception& e) {
68957       {
68958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68959       };
68960     } catch (Dali::DaliException e) {
68961       {
68962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68963       };
68964     } catch (...) {
68965       {
68966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68967       };
68968     }
68969   }
68970
68971   jresult = (void *)result;
68972   return jresult;
68973 }
68974
68975
68976 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
68977   unsigned int jresult ;
68978   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68979   unsigned int arg2 ;
68980   bool result;
68981
68982   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68983   arg2 = (unsigned int)jarg2;
68984   {
68985     try {
68986       result = (bool)(arg1)->Within(arg2);
68987     } catch (std::out_of_range& e) {
68988       {
68989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68990       };
68991     } catch (std::exception& e) {
68992       {
68993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68994       };
68995     } catch (Dali::DaliException e) {
68996       {
68997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68998       };
68999     } catch (...) {
69000       {
69001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69002       };
69003     }
69004   }
69005
69006   jresult = result;
69007   return jresult;
69008 }
69009
69010
69011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
69012   void * jresult ;
69013   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69014   Dali::Toolkit::ItemRange *arg2 = 0 ;
69015   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69016
69017   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69018   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69019   if (!arg2) {
69020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69021     return 0;
69022   }
69023   {
69024     try {
69025       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
69026     } catch (std::out_of_range& e) {
69027       {
69028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69029       };
69030     } catch (std::exception& e) {
69031       {
69032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69033       };
69034     } catch (Dali::DaliException e) {
69035       {
69036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69037       };
69038     } catch (...) {
69039       {
69040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69041       };
69042     }
69043   }
69044
69045   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69046   return jresult;
69047 }
69048
69049
69050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
69051   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69052   unsigned int arg2 ;
69053
69054   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69055   arg2 = (unsigned int)jarg2;
69056   if (arg1) (arg1)->begin = arg2;
69057 }
69058
69059
69060 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
69061   unsigned int jresult ;
69062   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69063   unsigned int result;
69064
69065   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69066   result = (unsigned int) ((arg1)->begin);
69067   jresult = result;
69068   return jresult;
69069 }
69070
69071
69072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
69073   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69074   unsigned int arg2 ;
69075
69076   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69077   arg2 = (unsigned int)jarg2;
69078   if (arg1) (arg1)->end = arg2;
69079 }
69080
69081
69082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
69083   unsigned int jresult ;
69084   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69085   unsigned int result;
69086
69087   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69088   result = (unsigned int) ((arg1)->end);
69089   jresult = result;
69090   return jresult;
69091 }
69092
69093
69094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
69095   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69096
69097   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69098   {
69099     try {
69100       delete arg1;
69101     } catch (std::out_of_range& e) {
69102       {
69103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69104       };
69105     } catch (std::exception& e) {
69106       {
69107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69108       };
69109     } catch (Dali::DaliException e) {
69110       {
69111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69112       };
69113     } catch (...) {
69114       {
69115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69116       };
69117     }
69118   }
69119
69120 }
69121
69122
69123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
69124   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69125
69126   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69127   {
69128     try {
69129       delete arg1;
69130     } catch (std::out_of_range& e) {
69131       {
69132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69133       };
69134     } catch (std::exception& e) {
69135       {
69136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69137       };
69138     } catch (Dali::DaliException e) {
69139       {
69140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69141       };
69142     } catch (...) {
69143       {
69144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69145       };
69146     }
69147   }
69148
69149 }
69150
69151
69152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
69153   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69154   Dali::Toolkit::ControlOrientation::Type arg2 ;
69155
69156   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69157   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
69158   {
69159     try {
69160       (arg1)->SetOrientation(arg2);
69161     } catch (std::out_of_range& e) {
69162       {
69163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69164       };
69165     } catch (std::exception& e) {
69166       {
69167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69168       };
69169     } catch (Dali::DaliException e) {
69170       {
69171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69172       };
69173     } catch (...) {
69174       {
69175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69176       };
69177     }
69178   }
69179
69180 }
69181
69182
69183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
69184   int jresult ;
69185   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69186   Dali::Toolkit::ControlOrientation::Type result;
69187
69188   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69189   {
69190     try {
69191       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
69192     } catch (std::out_of_range& e) {
69193       {
69194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69195       };
69196     } catch (std::exception& e) {
69197       {
69198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69199       };
69200     } catch (Dali::DaliException e) {
69201       {
69202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69203       };
69204     } catch (...) {
69205       {
69206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69207       };
69208     }
69209   }
69210
69211   jresult = (int)result;
69212   return jresult;
69213 }
69214
69215
69216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
69217   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69218   Dali::Property::Map *arg2 = 0 ;
69219
69220   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69221   arg2 = (Dali::Property::Map *)jarg2;
69222   if (!arg2) {
69223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
69224     return ;
69225   }
69226   {
69227     try {
69228       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
69229     } catch (std::out_of_range& e) {
69230       {
69231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69232       };
69233     } catch (std::exception& e) {
69234       {
69235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69236       };
69237     } catch (Dali::DaliException e) {
69238       {
69239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69240       };
69241     } catch (...) {
69242       {
69243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69244       };
69245     }
69246   }
69247
69248 }
69249
69250
69251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
69252   void * jresult ;
69253   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69254   Dali::Property::Map result;
69255
69256   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69257   {
69258     try {
69259       result = (arg1)->GetLayoutProperties();
69260     } catch (std::out_of_range& e) {
69261       {
69262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69263       };
69264     } catch (std::exception& e) {
69265       {
69266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69267       };
69268     } catch (Dali::DaliException e) {
69269       {
69270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69271       };
69272     } catch (...) {
69273       {
69274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69275       };
69276     }
69277   }
69278
69279   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
69280   return jresult;
69281 }
69282
69283
69284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69285   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69286   unsigned int arg2 ;
69287   Dali::Vector3 *arg3 = 0 ;
69288   Dali::Vector3 *arg4 = 0 ;
69289
69290   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69291   arg2 = (unsigned int)jarg2;
69292   arg3 = (Dali::Vector3 *)jarg3;
69293   if (!arg3) {
69294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69295     return ;
69296   }
69297   arg4 = (Dali::Vector3 *)jarg4;
69298   if (!arg4) {
69299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69300     return ;
69301   }
69302   {
69303     try {
69304       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69305     } catch (std::out_of_range& e) {
69306       {
69307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69308       };
69309     } catch (std::exception& e) {
69310       {
69311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69312       };
69313     } catch (Dali::DaliException e) {
69314       {
69315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69316       };
69317     } catch (...) {
69318       {
69319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69320       };
69321     }
69322   }
69323
69324 }
69325
69326
69327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
69328   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69329   Dali::Vector3 *arg2 = 0 ;
69330
69331   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69332   arg2 = (Dali::Vector3 *)jarg2;
69333   if (!arg2) {
69334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69335     return ;
69336   }
69337   {
69338     try {
69339       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
69340     } catch (std::out_of_range& e) {
69341       {
69342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69343       };
69344     } catch (std::exception& e) {
69345       {
69346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69347       };
69348     } catch (Dali::DaliException e) {
69349       {
69350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69351       };
69352     } catch (...) {
69353       {
69354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69355       };
69356     }
69357   }
69358
69359 }
69360
69361
69362 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
69363   float jresult ;
69364   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69365   unsigned int arg2 ;
69366   Dali::Vector3 arg3 ;
69367   Dali::Vector3 *argp3 ;
69368   float result;
69369
69370   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69371   arg2 = (unsigned int)jarg2;
69372   argp3 = (Dali::Vector3 *)jarg3;
69373   if (!argp3) {
69374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69375     return 0;
69376   }
69377   arg3 = *argp3;
69378   {
69379     try {
69380       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
69381     } catch (std::out_of_range& e) {
69382       {
69383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69384       };
69385     } catch (std::exception& e) {
69386       {
69387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69388       };
69389     } catch (Dali::DaliException e) {
69390       {
69391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69392       };
69393     } catch (...) {
69394       {
69395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69396       };
69397     }
69398   }
69399
69400   jresult = result;
69401   return jresult;
69402 }
69403
69404
69405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
69406   float jresult ;
69407   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69408   float arg2 ;
69409   float result;
69410
69411   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69412   arg2 = (float)jarg2;
69413   {
69414     try {
69415       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
69416     } catch (std::out_of_range& e) {
69417       {
69418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69419       };
69420     } catch (std::exception& e) {
69421       {
69422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69423       };
69424     } catch (Dali::DaliException e) {
69425       {
69426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69427       };
69428     } catch (...) {
69429       {
69430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69431       };
69432     }
69433   }
69434
69435   jresult = result;
69436   return jresult;
69437 }
69438
69439
69440 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
69441   float jresult ;
69442   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69443   unsigned int arg2 ;
69444   float result;
69445
69446   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69447   arg2 = (unsigned int)jarg2;
69448   {
69449     try {
69450       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
69451     } catch (std::out_of_range& e) {
69452       {
69453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69454       };
69455     } catch (std::exception& e) {
69456       {
69457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69458       };
69459     } catch (Dali::DaliException e) {
69460       {
69461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69462       };
69463     } catch (...) {
69464       {
69465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69466       };
69467     }
69468   }
69469
69470   jresult = result;
69471   return jresult;
69472 }
69473
69474
69475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
69476   void * jresult ;
69477   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69478   float arg2 ;
69479   Dali::Vector3 arg3 ;
69480   Dali::Vector3 *argp3 ;
69481   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69482
69483   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69484   arg2 = (float)jarg2;
69485   argp3 = (Dali::Vector3 *)jarg3;
69486   if (!argp3) {
69487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69488     return 0;
69489   }
69490   arg3 = *argp3;
69491   {
69492     try {
69493       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
69494     } catch (std::out_of_range& e) {
69495       {
69496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69497       };
69498     } catch (std::exception& e) {
69499       {
69500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69501       };
69502     } catch (Dali::DaliException e) {
69503       {
69504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69505       };
69506     } catch (...) {
69507       {
69508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69509       };
69510     }
69511   }
69512
69513   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69514   return jresult;
69515 }
69516
69517
69518 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69519   float jresult ;
69520   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69521   int arg2 ;
69522   float arg3 ;
69523   Dali::Vector3 *arg4 = 0 ;
69524   float result;
69525
69526   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69527   arg2 = (int)jarg2;
69528   arg3 = (float)jarg3;
69529   arg4 = (Dali::Vector3 *)jarg4;
69530   if (!arg4) {
69531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69532     return 0;
69533   }
69534   {
69535     try {
69536       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69537     } catch (std::out_of_range& e) {
69538       {
69539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69540       };
69541     } catch (std::exception& e) {
69542       {
69543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69544       };
69545     } catch (Dali::DaliException e) {
69546       {
69547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69548       };
69549     } catch (...) {
69550       {
69551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69552       };
69553     }
69554   }
69555
69556   jresult = result;
69557   return jresult;
69558 }
69559
69560
69561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
69562   unsigned int jresult ;
69563   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69564   Dali::Vector3 arg2 ;
69565   Dali::Vector3 *argp2 ;
69566   unsigned int result;
69567
69568   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69569   argp2 = (Dali::Vector3 *)jarg2;
69570   if (!argp2) {
69571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69572     return 0;
69573   }
69574   arg2 = *argp2;
69575   {
69576     try {
69577       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
69578     } catch (std::out_of_range& e) {
69579       {
69580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69581       };
69582     } catch (std::exception& e) {
69583       {
69584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69585       };
69586     } catch (Dali::DaliException e) {
69587       {
69588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69589       };
69590     } catch (...) {
69591       {
69592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69593       };
69594     }
69595   }
69596
69597   jresult = result;
69598   return jresult;
69599 }
69600
69601
69602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69603   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69604   unsigned int arg2 ;
69605   Dali::Vector3 *arg3 = 0 ;
69606   Dali::Vector3 *arg4 = 0 ;
69607
69608   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69609   arg2 = (unsigned int)jarg2;
69610   arg3 = (Dali::Vector3 *)jarg3;
69611   if (!arg3) {
69612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69613     return ;
69614   }
69615   arg4 = (Dali::Vector3 *)jarg4;
69616   if (!arg4) {
69617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69618     return ;
69619   }
69620   {
69621     try {
69622       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69623     } catch (std::out_of_range& e) {
69624       {
69625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69626       };
69627     } catch (std::exception& e) {
69628       {
69629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69630       };
69631     } catch (Dali::DaliException e) {
69632       {
69633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69634       };
69635     } catch (...) {
69636       {
69637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69638       };
69639     }
69640   }
69641
69642 }
69643
69644
69645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
69646   void * jresult ;
69647   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69648   Dali::Degree result;
69649
69650   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69651   {
69652     try {
69653       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
69654     } catch (std::out_of_range& e) {
69655       {
69656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69657       };
69658     } catch (std::exception& e) {
69659       {
69660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69661       };
69662     } catch (Dali::DaliException e) {
69663       {
69664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69665       };
69666     } catch (...) {
69667       {
69668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69669       };
69670     }
69671   }
69672
69673   jresult = new Dali::Degree((const Dali::Degree &)result);
69674   return jresult;
69675 }
69676
69677
69678 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
69679   float jresult ;
69680   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69681   float result;
69682
69683   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69684   {
69685     try {
69686       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
69687     } catch (std::out_of_range& e) {
69688       {
69689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69690       };
69691     } catch (std::exception& e) {
69692       {
69693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69694       };
69695     } catch (Dali::DaliException e) {
69696       {
69697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69698       };
69699     } catch (...) {
69700       {
69701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69702       };
69703     }
69704   }
69705
69706   jresult = result;
69707   return jresult;
69708 }
69709
69710
69711 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
69712   float jresult ;
69713   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69714   float result;
69715
69716   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69717   {
69718     try {
69719       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
69720     } catch (std::out_of_range& e) {
69721       {
69722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69723       };
69724     } catch (std::exception& e) {
69725       {
69726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69727       };
69728     } catch (Dali::DaliException e) {
69729       {
69730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69731       };
69732     } catch (...) {
69733       {
69734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69735       };
69736     }
69737   }
69738
69739   jresult = result;
69740   return jresult;
69741 }
69742
69743
69744 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
69745   float jresult ;
69746   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69747   float result;
69748
69749   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69750   {
69751     try {
69752       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
69753     } catch (std::out_of_range& e) {
69754       {
69755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69756       };
69757     } catch (std::exception& e) {
69758       {
69759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69760       };
69761     } catch (Dali::DaliException e) {
69762       {
69763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69764       };
69765     } catch (...) {
69766       {
69767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69768       };
69769     }
69770   }
69771
69772   jresult = result;
69773   return jresult;
69774 }
69775
69776
69777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
69778   int jresult ;
69779   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69780   int arg2 ;
69781   int arg3 ;
69782   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
69783   bool arg5 ;
69784   int result;
69785
69786   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69787   arg2 = (int)jarg2;
69788   arg3 = (int)jarg3;
69789   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
69790   arg5 = jarg5 ? true : false;
69791   {
69792     try {
69793       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
69794     } catch (std::out_of_range& e) {
69795       {
69796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69797       };
69798     } catch (std::exception& e) {
69799       {
69800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69801       };
69802     } catch (Dali::DaliException e) {
69803       {
69804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69805       };
69806     } catch (...) {
69807       {
69808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69809       };
69810     }
69811   }
69812
69813   jresult = result;
69814   return jresult;
69815 }
69816
69817
69818 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
69819   float jresult ;
69820   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69821   float result;
69822
69823   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69824   {
69825     try {
69826       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
69827     } catch (std::out_of_range& e) {
69828       {
69829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69830       };
69831     } catch (std::exception& e) {
69832       {
69833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69834       };
69835     } catch (Dali::DaliException e) {
69836       {
69837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69838       };
69839     } catch (...) {
69840       {
69841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69842       };
69843     }
69844   }
69845
69846   jresult = result;
69847   return jresult;
69848 }
69849
69850
69851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
69852   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69853   Dali::Actor *arg2 = 0 ;
69854   int arg3 ;
69855   Dali::Vector3 *arg4 = 0 ;
69856   Dali::Actor *arg5 = 0 ;
69857
69858   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69859   arg2 = (Dali::Actor *)jarg2;
69860   if (!arg2) {
69861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
69862     return ;
69863   }
69864   arg3 = (int)jarg3;
69865   arg4 = (Dali::Vector3 *)jarg4;
69866   if (!arg4) {
69867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69868     return ;
69869   }
69870   arg5 = (Dali::Actor *)jarg5;
69871   if (!arg5) {
69872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
69873     return ;
69874   }
69875   {
69876     try {
69877       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
69878     } catch (std::out_of_range& e) {
69879       {
69880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69881       };
69882     } catch (std::exception& e) {
69883       {
69884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69885       };
69886     } catch (Dali::DaliException e) {
69887       {
69888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69889       };
69890     } catch (...) {
69891       {
69892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69893       };
69894     }
69895   }
69896
69897 }
69898
69899
69900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69901   void * jresult ;
69902   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69903   int arg2 ;
69904   float arg3 ;
69905   Dali::Vector3 *arg4 = 0 ;
69906   Dali::Vector3 result;
69907
69908   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69909   arg2 = (int)jarg2;
69910   arg3 = (float)jarg3;
69911   arg4 = (Dali::Vector3 *)jarg4;
69912   if (!arg4) {
69913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69914     return 0;
69915   }
69916   {
69917     try {
69918       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69919     } catch (std::out_of_range& e) {
69920       {
69921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69922       };
69923     } catch (std::exception& e) {
69924       {
69925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69926       };
69927     } catch (Dali::DaliException e) {
69928       {
69929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69930       };
69931     } catch (...) {
69932       {
69933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69934       };
69935     }
69936   }
69937
69938   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
69939   return jresult;
69940 }
69941
69942
69943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
69944   void * jresult ;
69945   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
69946   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
69947
69948   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
69949   {
69950     try {
69951       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
69952     } catch (std::out_of_range& e) {
69953       {
69954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69955       };
69956     } catch (std::exception& e) {
69957       {
69958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69959       };
69960     } catch (Dali::DaliException e) {
69961       {
69962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69963       };
69964     } catch (...) {
69965       {
69966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69967       };
69968     }
69969   }
69970
69971   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
69972   return jresult;
69973 }
69974
69975
69976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
69977   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69978
69979   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69980   {
69981     try {
69982       delete arg1;
69983     } catch (std::out_of_range& e) {
69984       {
69985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69986       };
69987     } catch (std::exception& e) {
69988       {
69989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69990       };
69991     } catch (Dali::DaliException e) {
69992       {
69993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69994       };
69995     } catch (...) {
69996       {
69997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69998       };
69999     }
70000   }
70001
70002 }
70003
70004
70005 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
70006   unsigned int jresult ;
70007   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70008   unsigned int result;
70009
70010   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70011   {
70012     try {
70013       result = (unsigned int)(arg1)->GetNumberOfItems();
70014     } catch (std::out_of_range& e) {
70015       {
70016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70017       };
70018     } catch (std::exception& e) {
70019       {
70020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70021       };
70022     } catch (Dali::DaliException e) {
70023       {
70024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70025       };
70026     } catch (...) {
70027       {
70028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70029       };
70030     }
70031   }
70032
70033   jresult = result;
70034   return jresult;
70035 }
70036
70037
70038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
70039   void * jresult ;
70040   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70041   unsigned int arg2 ;
70042   Dali::Actor result;
70043
70044   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70045   arg2 = (unsigned int)jarg2;
70046   {
70047     try {
70048       result = (arg1)->NewItem(arg2);
70049     } catch (std::out_of_range& e) {
70050       {
70051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70052       };
70053     } catch (std::exception& e) {
70054       {
70055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70056       };
70057     } catch (Dali::DaliException e) {
70058       {
70059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70060       };
70061     } catch (...) {
70062       {
70063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70064       };
70065     }
70066   }
70067
70068   jresult = new Dali::Actor((const Dali::Actor &)result);
70069   return jresult;
70070 }
70071
70072
70073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
70074   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70075   unsigned int arg2 ;
70076   Dali::Actor arg3 ;
70077   Dali::Actor *argp3 ;
70078
70079   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70080   arg2 = (unsigned int)jarg2;
70081   argp3 = (Dali::Actor *)jarg3;
70082   if (!argp3) {
70083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70084     return ;
70085   }
70086   arg3 = *argp3;
70087   {
70088     try {
70089       (arg1)->ItemReleased(arg2,arg3);
70090     } catch (std::out_of_range& e) {
70091       {
70092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70093       };
70094     } catch (std::exception& e) {
70095       {
70096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70097       };
70098     } catch (Dali::DaliException e) {
70099       {
70100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70101       };
70102     } catch (...) {
70103       {
70104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70105       };
70106     }
70107   }
70108
70109 }
70110
70111
70112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
70113   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70114   unsigned int arg2 ;
70115   Dali::Actor arg3 ;
70116   Dali::Actor *argp3 ;
70117
70118   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70119   arg2 = (unsigned int)jarg2;
70120   argp3 = (Dali::Actor *)jarg3;
70121   if (!argp3) {
70122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70123     return ;
70124   }
70125   arg3 = *argp3;
70126   {
70127     try {
70128       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
70129     } catch (std::out_of_range& e) {
70130       {
70131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70132       };
70133     } catch (std::exception& e) {
70134       {
70135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70136       };
70137     } catch (Dali::DaliException e) {
70138       {
70139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70140       };
70141     } catch (...) {
70142       {
70143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70144       };
70145     }
70146   }
70147
70148 }
70149
70150
70151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
70152   void * jresult ;
70153   Dali::Toolkit::ItemFactory *result = 0 ;
70154
70155   {
70156     try {
70157       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
70158     } catch (std::out_of_range& e) {
70159       {
70160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70161       };
70162     } catch (std::exception& e) {
70163       {
70164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70165       };
70166     } catch (Dali::DaliException e) {
70167       {
70168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70169       };
70170     } catch (...) {
70171       {
70172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70173       };
70174     }
70175   }
70176
70177   jresult = (void *)result;
70178   return jresult;
70179 }
70180
70181
70182 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) {
70183   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
70184   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
70185   if (director) {
70186     director->swig_connect_director(callback0, callback1, callback2);
70187   }
70188 }
70189
70190
70191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
70192   int jresult ;
70193   int result;
70194
70195   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
70196   jresult = (int)result;
70197   return jresult;
70198 }
70199
70200
70201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
70202   int jresult ;
70203   int result;
70204
70205   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
70206   jresult = (int)result;
70207   return jresult;
70208 }
70209
70210
70211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
70212   int jresult ;
70213   int result;
70214
70215   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
70216   jresult = (int)result;
70217   return jresult;
70218 }
70219
70220
70221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
70222   int jresult ;
70223   int result;
70224
70225   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
70226   jresult = (int)result;
70227   return jresult;
70228 }
70229
70230
70231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
70232   int jresult ;
70233   int result;
70234
70235   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
70236   jresult = (int)result;
70237   return jresult;
70238 }
70239
70240
70241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
70242   int jresult ;
70243   int result;
70244
70245   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
70246   jresult = (int)result;
70247   return jresult;
70248 }
70249
70250
70251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
70252   int jresult ;
70253   int result;
70254
70255   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
70256   jresult = (int)result;
70257   return jresult;
70258 }
70259
70260
70261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
70262   int jresult ;
70263   int result;
70264
70265   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
70266   jresult = (int)result;
70267   return jresult;
70268 }
70269
70270
70271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
70272   int jresult ;
70273   int result;
70274
70275   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
70276   jresult = (int)result;
70277   return jresult;
70278 }
70279
70280
70281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
70282   int jresult ;
70283   int result;
70284
70285   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
70286   jresult = (int)result;
70287   return jresult;
70288 }
70289
70290
70291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
70292   int jresult ;
70293   int result;
70294
70295   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
70296   jresult = (int)result;
70297   return jresult;
70298 }
70299
70300
70301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
70302   void * jresult ;
70303   Dali::Toolkit::ItemView::Property *result = 0 ;
70304
70305   {
70306     try {
70307       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
70308     } catch (std::out_of_range& e) {
70309       {
70310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70311       };
70312     } catch (std::exception& e) {
70313       {
70314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70315       };
70316     } catch (Dali::DaliException e) {
70317       {
70318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70319       };
70320     } catch (...) {
70321       {
70322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70323       };
70324     }
70325   }
70326
70327   jresult = (void *)result;
70328   return jresult;
70329 }
70330
70331
70332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
70333   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
70334
70335   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
70336   {
70337     try {
70338       delete arg1;
70339     } catch (std::out_of_range& e) {
70340       {
70341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70342       };
70343     } catch (std::exception& e) {
70344       {
70345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70346       };
70347     } catch (Dali::DaliException e) {
70348       {
70349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70350       };
70351     } catch (...) {
70352       {
70353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70354       };
70355     }
70356   }
70357
70358 }
70359
70360
70361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
70362   void * jresult ;
70363   Dali::Toolkit::ItemView *result = 0 ;
70364
70365   {
70366     try {
70367       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
70368     } catch (std::out_of_range& e) {
70369       {
70370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70371       };
70372     } catch (std::exception& e) {
70373       {
70374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70375       };
70376     } catch (Dali::DaliException e) {
70377       {
70378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70379       };
70380     } catch (...) {
70381       {
70382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70383       };
70384     }
70385   }
70386
70387   jresult = (void *)result;
70388   return jresult;
70389 }
70390
70391
70392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
70393   void * jresult ;
70394   Dali::Toolkit::ItemView *arg1 = 0 ;
70395   Dali::Toolkit::ItemView *result = 0 ;
70396
70397   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70398   if (!arg1) {
70399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70400     return 0;
70401   }
70402   {
70403     try {
70404       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
70405     } catch (std::out_of_range& e) {
70406       {
70407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70408       };
70409     } catch (std::exception& e) {
70410       {
70411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70412       };
70413     } catch (Dali::DaliException e) {
70414       {
70415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70416       };
70417     } catch (...) {
70418       {
70419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70420       };
70421     }
70422   }
70423
70424   jresult = (void *)result;
70425   return jresult;
70426 }
70427
70428
70429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
70430   void * jresult ;
70431   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70432   Dali::Toolkit::ItemView *arg2 = 0 ;
70433   Dali::Toolkit::ItemView *result = 0 ;
70434
70435   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70436   arg2 = (Dali::Toolkit::ItemView *)jarg2;
70437   if (!arg2) {
70438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70439     return 0;
70440   }
70441   {
70442     try {
70443       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
70444     } catch (std::out_of_range& e) {
70445       {
70446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70447       };
70448     } catch (std::exception& e) {
70449       {
70450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70451       };
70452     } catch (Dali::DaliException e) {
70453       {
70454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70455       };
70456     } catch (...) {
70457       {
70458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70459       };
70460     }
70461   }
70462
70463   jresult = (void *)result;
70464   return jresult;
70465 }
70466
70467
70468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
70469   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70470
70471   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70472   {
70473     try {
70474       delete arg1;
70475     } catch (std::out_of_range& e) {
70476       {
70477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70478       };
70479     } catch (std::exception& e) {
70480       {
70481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70482       };
70483     } catch (Dali::DaliException e) {
70484       {
70485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70486       };
70487     } catch (...) {
70488       {
70489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70490       };
70491     }
70492   }
70493
70494 }
70495
70496
70497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
70498   void * jresult ;
70499   Dali::Toolkit::ItemFactory *arg1 = 0 ;
70500   Dali::Toolkit::ItemView result;
70501
70502   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70503   if (!arg1) {
70504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
70505     return 0;
70506   }
70507   {
70508     try {
70509       result = Dali::Toolkit::ItemView::New(*arg1);
70510     } catch (std::out_of_range& e) {
70511       {
70512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70513       };
70514     } catch (std::exception& e) {
70515       {
70516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70517       };
70518     } catch (Dali::DaliException e) {
70519       {
70520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70521       };
70522     } catch (...) {
70523       {
70524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70525       };
70526     }
70527   }
70528
70529   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70530   return jresult;
70531 }
70532
70533
70534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
70535   void * jresult ;
70536   Dali::BaseHandle arg1 ;
70537   Dali::BaseHandle *argp1 ;
70538   Dali::Toolkit::ItemView result;
70539
70540   argp1 = (Dali::BaseHandle *)jarg1;
70541   if (!argp1) {
70542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70543     return 0;
70544   }
70545   arg1 = *argp1;
70546   {
70547     try {
70548       result = Dali::Toolkit::ItemView::DownCast(arg1);
70549     } catch (std::out_of_range& e) {
70550       {
70551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70552       };
70553     } catch (std::exception& e) {
70554       {
70555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70556       };
70557     } catch (Dali::DaliException e) {
70558       {
70559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70560       };
70561     } catch (...) {
70562       {
70563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70564       };
70565     }
70566   }
70567
70568   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70569   return jresult;
70570 }
70571
70572
70573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
70574   unsigned int jresult ;
70575   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70576   unsigned int result;
70577
70578   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70579   {
70580     try {
70581       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
70582     } catch (std::out_of_range& e) {
70583       {
70584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70585       };
70586     } catch (std::exception& e) {
70587       {
70588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70589       };
70590     } catch (Dali::DaliException e) {
70591       {
70592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70593       };
70594     } catch (...) {
70595       {
70596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70597       };
70598     }
70599   }
70600
70601   jresult = result;
70602   return jresult;
70603 }
70604
70605
70606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
70607   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70608   Dali::Toolkit::ItemLayout *arg2 = 0 ;
70609
70610   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70611   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
70612   if (!arg2) {
70613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
70614     return ;
70615   }
70616   {
70617     try {
70618       (arg1)->AddLayout(*arg2);
70619     } catch (std::out_of_range& e) {
70620       {
70621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70622       };
70623     } catch (std::exception& e) {
70624       {
70625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70626       };
70627     } catch (Dali::DaliException e) {
70628       {
70629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70630       };
70631     } catch (...) {
70632       {
70633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70634       };
70635     }
70636   }
70637
70638 }
70639
70640
70641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
70642   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70643   unsigned int arg2 ;
70644
70645   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70646   arg2 = (unsigned int)jarg2;
70647   {
70648     try {
70649       (arg1)->RemoveLayout(arg2);
70650     } catch (std::out_of_range& e) {
70651       {
70652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70653       };
70654     } catch (std::exception& e) {
70655       {
70656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70657       };
70658     } catch (Dali::DaliException e) {
70659       {
70660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70661       };
70662     } catch (...) {
70663       {
70664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70665       };
70666     }
70667   }
70668
70669 }
70670
70671
70672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
70673   void * jresult ;
70674   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70675   unsigned int arg2 ;
70676   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70677
70678   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70679   arg2 = (unsigned int)jarg2;
70680   {
70681     try {
70682       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
70683     } catch (std::out_of_range& e) {
70684       {
70685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70686       };
70687     } catch (std::exception& e) {
70688       {
70689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70690       };
70691     } catch (Dali::DaliException e) {
70692       {
70693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70694       };
70695     } catch (...) {
70696       {
70697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70698       };
70699     }
70700   }
70701
70702   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70703   return jresult;
70704 }
70705
70706
70707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
70708   void * jresult ;
70709   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70710   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70711
70712   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70713   {
70714     try {
70715       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
70716     } catch (std::out_of_range& e) {
70717       {
70718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70719       };
70720     } catch (std::exception& e) {
70721       {
70722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70723       };
70724     } catch (Dali::DaliException e) {
70725       {
70726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70727       };
70728     } catch (...) {
70729       {
70730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70731       };
70732     }
70733   }
70734
70735   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70736   return jresult;
70737 }
70738
70739
70740 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
70741   float jresult ;
70742   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70743   Dali::Toolkit::ItemId arg2 ;
70744   float result;
70745
70746   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70747   arg2 = (Dali::Toolkit::ItemId)jarg2;
70748   {
70749     try {
70750       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
70751     } catch (std::out_of_range& e) {
70752       {
70753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70754       };
70755     } catch (std::exception& e) {
70756       {
70757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70758       };
70759     } catch (Dali::DaliException e) {
70760       {
70761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70762       };
70763     } catch (...) {
70764       {
70765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70766       };
70767     }
70768   }
70769
70770   jresult = result;
70771   return jresult;
70772 }
70773
70774
70775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
70776   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70777   unsigned int arg2 ;
70778   Dali::Vector3 arg3 ;
70779   float arg4 ;
70780   Dali::Vector3 *argp3 ;
70781
70782   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70783   arg2 = (unsigned int)jarg2;
70784   argp3 = (Dali::Vector3 *)jarg3;
70785   if (!argp3) {
70786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70787     return ;
70788   }
70789   arg3 = *argp3;
70790   arg4 = (float)jarg4;
70791   {
70792     try {
70793       (arg1)->ActivateLayout(arg2,arg3,arg4);
70794     } catch (std::out_of_range& e) {
70795       {
70796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70797       };
70798     } catch (std::exception& e) {
70799       {
70800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70801       };
70802     } catch (Dali::DaliException e) {
70803       {
70804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70805       };
70806     } catch (...) {
70807       {
70808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70809       };
70810     }
70811   }
70812
70813 }
70814
70815
70816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
70817   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70818
70819   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70820   {
70821     try {
70822       (arg1)->DeactivateCurrentLayout();
70823     } catch (std::out_of_range& e) {
70824       {
70825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70826       };
70827     } catch (std::exception& e) {
70828       {
70829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70830       };
70831     } catch (Dali::DaliException e) {
70832       {
70833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70834       };
70835     } catch (...) {
70836       {
70837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70838       };
70839     }
70840   }
70841
70842 }
70843
70844
70845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
70846   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70847   float arg2 ;
70848
70849   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70850   arg2 = (float)jarg2;
70851   {
70852     try {
70853       (arg1)->SetMinimumSwipeSpeed(arg2);
70854     } catch (std::out_of_range& e) {
70855       {
70856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70857       };
70858     } catch (std::exception& e) {
70859       {
70860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70861       };
70862     } catch (Dali::DaliException e) {
70863       {
70864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70865       };
70866     } catch (...) {
70867       {
70868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70869       };
70870     }
70871   }
70872
70873 }
70874
70875
70876 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
70877   float jresult ;
70878   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70879   float result;
70880
70881   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70882   {
70883     try {
70884       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
70885     } catch (std::out_of_range& e) {
70886       {
70887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70888       };
70889     } catch (std::exception& e) {
70890       {
70891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70892       };
70893     } catch (Dali::DaliException e) {
70894       {
70895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70896       };
70897     } catch (...) {
70898       {
70899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70900       };
70901     }
70902   }
70903
70904   jresult = result;
70905   return jresult;
70906 }
70907
70908
70909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
70910   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70911   float arg2 ;
70912
70913   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70914   arg2 = (float)jarg2;
70915   {
70916     try {
70917       (arg1)->SetMinimumSwipeDistance(arg2);
70918     } catch (std::out_of_range& e) {
70919       {
70920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70921       };
70922     } catch (std::exception& e) {
70923       {
70924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70925       };
70926     } catch (Dali::DaliException e) {
70927       {
70928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70929       };
70930     } catch (...) {
70931       {
70932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70933       };
70934     }
70935   }
70936
70937 }
70938
70939
70940 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
70941   float jresult ;
70942   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70943   float result;
70944
70945   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70946   {
70947     try {
70948       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
70949     } catch (std::out_of_range& e) {
70950       {
70951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70952       };
70953     } catch (std::exception& e) {
70954       {
70955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70956       };
70957     } catch (Dali::DaliException e) {
70958       {
70959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70960       };
70961     } catch (...) {
70962       {
70963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70964       };
70965     }
70966   }
70967
70968   jresult = result;
70969   return jresult;
70970 }
70971
70972
70973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
70974   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70975   float arg2 ;
70976
70977   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70978   arg2 = (float)jarg2;
70979   {
70980     try {
70981       (arg1)->SetWheelScrollDistanceStep(arg2);
70982     } catch (std::out_of_range& e) {
70983       {
70984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70985       };
70986     } catch (std::exception& e) {
70987       {
70988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70989       };
70990     } catch (Dali::DaliException e) {
70991       {
70992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70993       };
70994     } catch (...) {
70995       {
70996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70997       };
70998     }
70999   }
71000
71001 }
71002
71003
71004 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
71005   float jresult ;
71006   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71007   float result;
71008
71009   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71010   {
71011     try {
71012       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
71013     } catch (std::out_of_range& e) {
71014       {
71015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71016       };
71017     } catch (std::exception& e) {
71018       {
71019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71020       };
71021     } catch (Dali::DaliException e) {
71022       {
71023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71024       };
71025     } catch (...) {
71026       {
71027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71028       };
71029     }
71030   }
71031
71032   jresult = result;
71033   return jresult;
71034 }
71035
71036
71037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
71038   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71039   bool arg2 ;
71040
71041   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71042   arg2 = jarg2 ? true : false;
71043   {
71044     try {
71045       (arg1)->SetAnchoring(arg2);
71046     } catch (std::out_of_range& e) {
71047       {
71048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71049       };
71050     } catch (std::exception& e) {
71051       {
71052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71053       };
71054     } catch (Dali::DaliException e) {
71055       {
71056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71057       };
71058     } catch (...) {
71059       {
71060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71061       };
71062     }
71063   }
71064
71065 }
71066
71067 //// ========================= end of part 3 =============================
71068
71069 //// ========================== start part 4 ===============================
71070
71071
71072 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
71073   unsigned int jresult ;
71074   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71075   bool result;
71076
71077   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71078   {
71079     try {
71080       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
71081     } catch (std::out_of_range& e) {
71082       {
71083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71084       };
71085     } catch (std::exception& e) {
71086       {
71087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71088       };
71089     } catch (Dali::DaliException e) {
71090       {
71091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71092       };
71093     } catch (...) {
71094       {
71095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71096       };
71097     }
71098   }
71099
71100   jresult = result;
71101   return jresult;
71102 }
71103
71104
71105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
71106   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71107   float arg2 ;
71108
71109   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71110   arg2 = (float)jarg2;
71111   {
71112     try {
71113       (arg1)->SetAnchoringDuration(arg2);
71114     } catch (std::out_of_range& e) {
71115       {
71116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71117       };
71118     } catch (std::exception& e) {
71119       {
71120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71121       };
71122     } catch (Dali::DaliException e) {
71123       {
71124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71125       };
71126     } catch (...) {
71127       {
71128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71129       };
71130     }
71131   }
71132
71133 }
71134
71135
71136 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
71137   float jresult ;
71138   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71139   float result;
71140
71141   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71142   {
71143     try {
71144       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
71145     } catch (std::out_of_range& e) {
71146       {
71147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71148       };
71149     } catch (std::exception& e) {
71150       {
71151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71152       };
71153     } catch (Dali::DaliException e) {
71154       {
71155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71156       };
71157     } catch (...) {
71158       {
71159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71160       };
71161     }
71162   }
71163
71164   jresult = result;
71165   return jresult;
71166 }
71167
71168
71169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
71170   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71171   Dali::Toolkit::ItemId arg2 ;
71172   float arg3 ;
71173
71174   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71175   arg2 = (Dali::Toolkit::ItemId)jarg2;
71176   arg3 = (float)jarg3;
71177   {
71178     try {
71179       (arg1)->ScrollToItem(arg2,arg3);
71180     } catch (std::out_of_range& e) {
71181       {
71182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71183       };
71184     } catch (std::exception& e) {
71185       {
71186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71187       };
71188     } catch (Dali::DaliException e) {
71189       {
71190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71191       };
71192     } catch (...) {
71193       {
71194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71195       };
71196     }
71197   }
71198
71199 }
71200
71201
71202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
71203   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71204   float arg2 ;
71205
71206   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71207   arg2 = (float)jarg2;
71208   {
71209     try {
71210       (arg1)->SetRefreshInterval(arg2);
71211     } catch (std::out_of_range& e) {
71212       {
71213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71214       };
71215     } catch (std::exception& e) {
71216       {
71217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71218       };
71219     } catch (Dali::DaliException e) {
71220       {
71221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71222       };
71223     } catch (...) {
71224       {
71225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71226       };
71227     }
71228   }
71229
71230 }
71231
71232
71233 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
71234   float jresult ;
71235   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71236   float result;
71237
71238   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71239   {
71240     try {
71241       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
71242     } catch (std::out_of_range& e) {
71243       {
71244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71245       };
71246     } catch (std::exception& e) {
71247       {
71248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71249       };
71250     } catch (Dali::DaliException e) {
71251       {
71252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71253       };
71254     } catch (...) {
71255       {
71256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71257       };
71258     }
71259   }
71260
71261   jresult = result;
71262   return jresult;
71263 }
71264
71265
71266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
71267   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71268
71269   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71270   {
71271     try {
71272       (arg1)->Refresh();
71273     } catch (std::out_of_range& e) {
71274       {
71275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71276       };
71277     } catch (std::exception& e) {
71278       {
71279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71280       };
71281     } catch (Dali::DaliException e) {
71282       {
71283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71284       };
71285     } catch (...) {
71286       {
71287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71288       };
71289     }
71290   }
71291
71292 }
71293
71294
71295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
71296   void * jresult ;
71297   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71298   Dali::Toolkit::ItemId arg2 ;
71299   Dali::Actor result;
71300
71301   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71302   arg2 = (Dali::Toolkit::ItemId)jarg2;
71303   {
71304     try {
71305       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
71306     } catch (std::out_of_range& e) {
71307       {
71308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71309       };
71310     } catch (std::exception& e) {
71311       {
71312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71313       };
71314     } catch (Dali::DaliException e) {
71315       {
71316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71317       };
71318     } catch (...) {
71319       {
71320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71321       };
71322     }
71323   }
71324
71325   jresult = new Dali::Actor((const Dali::Actor &)result);
71326   return jresult;
71327 }
71328
71329
71330 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
71331   unsigned int jresult ;
71332   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71333   Dali::Actor arg2 ;
71334   Dali::Actor *argp2 ;
71335   Dali::Toolkit::ItemId result;
71336
71337   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71338   argp2 = (Dali::Actor *)jarg2;
71339   if (!argp2) {
71340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71341     return 0;
71342   }
71343   arg2 = *argp2;
71344   {
71345     try {
71346       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
71347     } catch (std::out_of_range& e) {
71348       {
71349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71350       };
71351     } catch (std::exception& e) {
71352       {
71353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71354       };
71355     } catch (Dali::DaliException e) {
71356       {
71357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71358       };
71359     } catch (...) {
71360       {
71361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71362       };
71363     }
71364   }
71365
71366   jresult = result;
71367   return jresult;
71368 }
71369
71370
71371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
71372   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71373   Dali::Toolkit::Item arg2 ;
71374   float arg3 ;
71375   Dali::Toolkit::Item *argp2 ;
71376
71377   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71378   argp2 = (Dali::Toolkit::Item *)jarg2;
71379   if (!argp2) {
71380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71381     return ;
71382   }
71383   arg2 = *argp2;
71384   arg3 = (float)jarg3;
71385   {
71386     try {
71387       (arg1)->InsertItem(arg2,arg3);
71388     } catch (std::out_of_range& e) {
71389       {
71390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71391       };
71392     } catch (std::exception& e) {
71393       {
71394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71395       };
71396     } catch (Dali::DaliException e) {
71397       {
71398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71399       };
71400     } catch (...) {
71401       {
71402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71403       };
71404     }
71405   }
71406
71407 }
71408
71409
71410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
71411   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71412   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71413   float arg3 ;
71414
71415   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71416   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71417   if (!arg2) {
71418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71419     return ;
71420   }
71421   arg3 = (float)jarg3;
71422   {
71423     try {
71424       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71425     } catch (std::out_of_range& e) {
71426       {
71427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71428       };
71429     } catch (std::exception& e) {
71430       {
71431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71432       };
71433     } catch (Dali::DaliException e) {
71434       {
71435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71436       };
71437     } catch (...) {
71438       {
71439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71440       };
71441     }
71442   }
71443
71444 }
71445
71446
71447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
71448   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71449   Dali::Toolkit::ItemId arg2 ;
71450   float arg3 ;
71451
71452   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71453   arg2 = (Dali::Toolkit::ItemId)jarg2;
71454   arg3 = (float)jarg3;
71455   {
71456     try {
71457       (arg1)->RemoveItem(arg2,arg3);
71458     } catch (std::out_of_range& e) {
71459       {
71460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71461       };
71462     } catch (std::exception& e) {
71463       {
71464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71465       };
71466     } catch (Dali::DaliException e) {
71467       {
71468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71469       };
71470     } catch (...) {
71471       {
71472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71473       };
71474     }
71475   }
71476
71477 }
71478
71479
71480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
71481   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71482   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
71483   float arg3 ;
71484
71485   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71486   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
71487   if (!arg2) {
71488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
71489     return ;
71490   }
71491   arg3 = (float)jarg3;
71492   {
71493     try {
71494       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
71495     } catch (std::out_of_range& e) {
71496       {
71497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71498       };
71499     } catch (std::exception& e) {
71500       {
71501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71502       };
71503     } catch (Dali::DaliException e) {
71504       {
71505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71506       };
71507     } catch (...) {
71508       {
71509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71510       };
71511     }
71512   }
71513
71514 }
71515
71516
71517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
71518   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71519   Dali::Toolkit::Item arg2 ;
71520   float arg3 ;
71521   Dali::Toolkit::Item *argp2 ;
71522
71523   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71524   argp2 = (Dali::Toolkit::Item *)jarg2;
71525   if (!argp2) {
71526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71527     return ;
71528   }
71529   arg2 = *argp2;
71530   arg3 = (float)jarg3;
71531   {
71532     try {
71533       (arg1)->ReplaceItem(arg2,arg3);
71534     } catch (std::out_of_range& e) {
71535       {
71536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71537       };
71538     } catch (std::exception& e) {
71539       {
71540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71541       };
71542     } catch (Dali::DaliException e) {
71543       {
71544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71545       };
71546     } catch (...) {
71547       {
71548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71549       };
71550     }
71551   }
71552
71553 }
71554
71555
71556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
71557   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71558   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71559   float arg3 ;
71560
71561   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71562   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71563   if (!arg2) {
71564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71565     return ;
71566   }
71567   arg3 = (float)jarg3;
71568   {
71569     try {
71570       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71571     } catch (std::out_of_range& e) {
71572       {
71573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71574       };
71575     } catch (std::exception& e) {
71576       {
71577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71578       };
71579     } catch (Dali::DaliException e) {
71580       {
71581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71582       };
71583     } catch (...) {
71584       {
71585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71586       };
71587     }
71588   }
71589
71590 }
71591
71592
71593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
71594   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71595   Dali::Vector3 *arg2 = 0 ;
71596
71597   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71598   arg2 = (Dali::Vector3 *)jarg2;
71599   if (!arg2) {
71600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71601     return ;
71602   }
71603   {
71604     try {
71605       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
71606     } catch (std::out_of_range& e) {
71607       {
71608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71609       };
71610     } catch (std::exception& e) {
71611       {
71612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71613       };
71614     } catch (Dali::DaliException e) {
71615       {
71616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71617       };
71618     } catch (...) {
71619       {
71620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71621       };
71622     }
71623   }
71624
71625 }
71626
71627
71628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
71629   void * jresult ;
71630   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71631   Dali::Vector3 result;
71632
71633   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71634   {
71635     try {
71636       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
71637     } catch (std::out_of_range& e) {
71638       {
71639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71640       };
71641     } catch (std::exception& e) {
71642       {
71643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71644       };
71645     } catch (Dali::DaliException e) {
71646       {
71647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71648       };
71649     } catch (...) {
71650       {
71651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71652       };
71653     }
71654   }
71655
71656   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71657   return jresult;
71658 }
71659
71660
71661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
71662   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71663   Dali::Vector3 *arg2 = 0 ;
71664
71665   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71666   arg2 = (Dali::Vector3 *)jarg2;
71667   if (!arg2) {
71668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71669     return ;
71670   }
71671   {
71672     try {
71673       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
71674     } catch (std::out_of_range& e) {
71675       {
71676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71677       };
71678     } catch (std::exception& e) {
71679       {
71680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71681       };
71682     } catch (Dali::DaliException e) {
71683       {
71684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71685       };
71686     } catch (...) {
71687       {
71688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71689       };
71690     }
71691   }
71692
71693 }
71694
71695
71696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
71697   void * jresult ;
71698   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71699   Dali::Vector3 result;
71700
71701   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71702   {
71703     try {
71704       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
71705     } catch (std::out_of_range& e) {
71706       {
71707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71708       };
71709     } catch (std::exception& e) {
71710       {
71711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71712       };
71713     } catch (Dali::DaliException e) {
71714       {
71715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71716       };
71717     } catch (...) {
71718       {
71719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71720       };
71721     }
71722   }
71723
71724   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71725   return jresult;
71726 }
71727
71728
71729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
71730   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71731   Dali::Toolkit::ItemRange *arg2 = 0 ;
71732
71733   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71734   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
71735   if (!arg2) {
71736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
71737     return ;
71738   }
71739   {
71740     try {
71741       (arg1)->GetItemsRange(*arg2);
71742     } catch (std::out_of_range& e) {
71743       {
71744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71745       };
71746     } catch (std::exception& e) {
71747       {
71748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71749       };
71750     } catch (Dali::DaliException e) {
71751       {
71752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71753       };
71754     } catch (...) {
71755       {
71756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71757       };
71758     }
71759   }
71760
71761 }
71762
71763
71764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
71765   void * jresult ;
71766   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71767   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
71768
71769   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71770   {
71771     try {
71772       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
71773     } catch (std::out_of_range& e) {
71774       {
71775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71776       };
71777     } catch (std::exception& e) {
71778       {
71779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71780       };
71781     } catch (Dali::DaliException e) {
71782       {
71783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71784       };
71785     } catch (...) {
71786       {
71787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71788       };
71789     }
71790   }
71791
71792   jresult = (void *)result;
71793   return jresult;
71794 }
71795
71796
71797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
71798   Dali::Vector3 *arg1 = 0 ;
71799   PropertyInputContainer *arg2 = 0 ;
71800
71801   arg1 = (Dali::Vector3 *)jarg1;
71802   if (!arg1) {
71803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71804     return ;
71805   }
71806   arg2 = (PropertyInputContainer *)jarg2;
71807   if (!arg2) {
71808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71809     return ;
71810   }
71811   {
71812     try {
71813       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71814     } catch (std::out_of_range& e) {
71815       {
71816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71817       };
71818     } catch (std::exception& e) {
71819       {
71820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71821       };
71822     } catch (Dali::DaliException e) {
71823       {
71824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71825       };
71826     } catch (...) {
71827       {
71828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71829       };
71830     }
71831   }
71832
71833 }
71834
71835
71836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
71837   Dali::Vector3 *arg1 = 0 ;
71838   PropertyInputContainer *arg2 = 0 ;
71839
71840   arg1 = (Dali::Vector3 *)jarg1;
71841   if (!arg1) {
71842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71843     return ;
71844   }
71845   arg2 = (PropertyInputContainer *)jarg2;
71846   if (!arg2) {
71847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71848     return ;
71849   }
71850   {
71851     try {
71852       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71853     } catch (std::out_of_range& e) {
71854       {
71855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71856       };
71857     } catch (std::exception& e) {
71858       {
71859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71860       };
71861     } catch (Dali::DaliException e) {
71862       {
71863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71864       };
71865     } catch (...) {
71866       {
71867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71868       };
71869     }
71870   }
71871
71872 }
71873
71874
71875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
71876   void * jresult ;
71877   Dali::Toolkit::ScrollViewEffect *result = 0 ;
71878
71879   {
71880     try {
71881       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
71882     } catch (std::out_of_range& e) {
71883       {
71884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71885       };
71886     } catch (std::exception& e) {
71887       {
71888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71889       };
71890     } catch (Dali::DaliException e) {
71891       {
71892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71893       };
71894     } catch (...) {
71895       {
71896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71897       };
71898     }
71899   }
71900
71901   jresult = (void *)result;
71902   return jresult;
71903 }
71904
71905
71906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
71907   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
71908
71909   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
71910   {
71911     try {
71912       delete arg1;
71913     } catch (std::out_of_range& e) {
71914       {
71915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71916       };
71917     } catch (std::exception& e) {
71918       {
71919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71920       };
71921     } catch (Dali::DaliException e) {
71922       {
71923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71924       };
71925     } catch (...) {
71926       {
71927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71928       };
71929     }
71930   }
71931
71932 }
71933
71934
71935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
71936   void * jresult ;
71937   Dali::Path arg1 ;
71938   Dali::Vector3 *arg2 = 0 ;
71939   Dali::Property::Index arg3 ;
71940   Dali::Vector3 *arg4 = 0 ;
71941   unsigned int arg5 ;
71942   Dali::Path *argp1 ;
71943   Dali::Toolkit::ScrollViewPagePathEffect result;
71944
71945   argp1 = (Dali::Path *)jarg1;
71946   if (!argp1) {
71947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
71948     return 0;
71949   }
71950   arg1 = *argp1;
71951   arg2 = (Dali::Vector3 *)jarg2;
71952   if (!arg2) {
71953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71954     return 0;
71955   }
71956   arg3 = (Dali::Property::Index)jarg3;
71957   arg4 = (Dali::Vector3 *)jarg4;
71958   if (!arg4) {
71959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71960     return 0;
71961   }
71962   arg5 = (unsigned int)jarg5;
71963   {
71964     try {
71965       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
71966     } catch (std::out_of_range& e) {
71967       {
71968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71969       };
71970     } catch (std::exception& e) {
71971       {
71972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71973       };
71974     } catch (Dali::DaliException e) {
71975       {
71976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71977       };
71978     } catch (...) {
71979       {
71980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71981       };
71982     }
71983   }
71984
71985   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
71986   return jresult;
71987 }
71988
71989
71990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
71991   void * jresult ;
71992   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
71993
71994   {
71995     try {
71996       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
71997     } catch (std::out_of_range& e) {
71998       {
71999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72000       };
72001     } catch (std::exception& e) {
72002       {
72003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72004       };
72005     } catch (Dali::DaliException e) {
72006       {
72007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72008       };
72009     } catch (...) {
72010       {
72011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72012       };
72013     }
72014   }
72015
72016   jresult = (void *)result;
72017   return jresult;
72018 }
72019
72020
72021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
72022   void * jresult ;
72023   Dali::BaseHandle arg1 ;
72024   Dali::BaseHandle *argp1 ;
72025   Dali::Toolkit::ScrollViewPagePathEffect result;
72026
72027   argp1 = (Dali::BaseHandle *)jarg1;
72028   if (!argp1) {
72029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72030     return 0;
72031   }
72032   arg1 = *argp1;
72033   {
72034     try {
72035       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
72036     } catch (std::out_of_range& e) {
72037       {
72038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72039       };
72040     } catch (std::exception& e) {
72041       {
72042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72043       };
72044     } catch (Dali::DaliException e) {
72045       {
72046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72047       };
72048     } catch (...) {
72049       {
72050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72051       };
72052     }
72053   }
72054
72055   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72056   return jresult;
72057 }
72058
72059
72060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
72061   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72062   Dali::Actor arg2 ;
72063   unsigned int arg3 ;
72064   Dali::Actor *argp2 ;
72065
72066   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72067   argp2 = (Dali::Actor *)jarg2;
72068   if (!argp2) {
72069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72070     return ;
72071   }
72072   arg2 = *argp2;
72073   arg3 = (unsigned int)jarg3;
72074   {
72075     try {
72076       (arg1)->ApplyToPage(arg2,arg3);
72077     } catch (std::out_of_range& e) {
72078       {
72079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72080       };
72081     } catch (std::exception& e) {
72082       {
72083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72084       };
72085     } catch (Dali::DaliException e) {
72086       {
72087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72088       };
72089     } catch (...) {
72090       {
72091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72092       };
72093     }
72094   }
72095
72096 }
72097
72098
72099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
72100   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72101
72102   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72103   {
72104     try {
72105       delete arg1;
72106     } catch (std::out_of_range& e) {
72107       {
72108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72109       };
72110     } catch (std::exception& e) {
72111       {
72112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72113       };
72114     } catch (Dali::DaliException e) {
72115       {
72116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72117       };
72118     } catch (...) {
72119       {
72120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72121       };
72122     }
72123   }
72124
72125 }
72126
72127
72128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
72129   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72130   Dali::Toolkit::ClampState arg2 ;
72131
72132   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72133   arg2 = (Dali::Toolkit::ClampState)jarg2;
72134   if (arg1) (arg1)->x = arg2;
72135 }
72136
72137
72138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
72139   int jresult ;
72140   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72141   Dali::Toolkit::ClampState result;
72142
72143   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72144   result = (Dali::Toolkit::ClampState) ((arg1)->x);
72145   jresult = (int)result;
72146   return jresult;
72147 }
72148
72149
72150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
72151   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72152   Dali::Toolkit::ClampState arg2 ;
72153
72154   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72155   arg2 = (Dali::Toolkit::ClampState)jarg2;
72156   if (arg1) (arg1)->y = arg2;
72157 }
72158
72159
72160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
72161   int jresult ;
72162   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72163   Dali::Toolkit::ClampState result;
72164
72165   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72166   result = (Dali::Toolkit::ClampState) ((arg1)->y);
72167   jresult = (int)result;
72168   return jresult;
72169 }
72170
72171
72172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
72173   void * jresult ;
72174   Dali::Toolkit::ClampState2D *result = 0 ;
72175
72176   {
72177     try {
72178       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
72179     } catch (std::out_of_range& e) {
72180       {
72181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72182       };
72183     } catch (std::exception& e) {
72184       {
72185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72186       };
72187     } catch (Dali::DaliException e) {
72188       {
72189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72190       };
72191     } catch (...) {
72192       {
72193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72194       };
72195     }
72196   }
72197
72198   jresult = (void *)result;
72199   return jresult;
72200 }
72201
72202
72203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
72204   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72205
72206   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72207   {
72208     try {
72209       delete arg1;
72210     } catch (std::out_of_range& e) {
72211       {
72212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72213       };
72214     } catch (std::exception& e) {
72215       {
72216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72217       };
72218     } catch (Dali::DaliException e) {
72219       {
72220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72221       };
72222     } catch (...) {
72223       {
72224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72225       };
72226     }
72227   }
72228
72229 }
72230
72231
72232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
72233   void * jresult ;
72234   float arg1 ;
72235   float arg2 ;
72236   bool arg3 ;
72237   Dali::Toolkit::RulerDomain *result = 0 ;
72238
72239   arg1 = (float)jarg1;
72240   arg2 = (float)jarg2;
72241   arg3 = jarg3 ? true : false;
72242   {
72243     try {
72244       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
72245     } catch (std::out_of_range& e) {
72246       {
72247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72248       };
72249     } catch (std::exception& e) {
72250       {
72251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72252       };
72253     } catch (Dali::DaliException e) {
72254       {
72255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72256       };
72257     } catch (...) {
72258       {
72259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72260       };
72261     }
72262   }
72263
72264   jresult = (void *)result;
72265   return jresult;
72266 }
72267
72268
72269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
72270   void * jresult ;
72271   float arg1 ;
72272   float arg2 ;
72273   Dali::Toolkit::RulerDomain *result = 0 ;
72274
72275   arg1 = (float)jarg1;
72276   arg2 = (float)jarg2;
72277   {
72278     try {
72279       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
72280     } catch (std::out_of_range& e) {
72281       {
72282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72283       };
72284     } catch (std::exception& e) {
72285       {
72286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72287       };
72288     } catch (Dali::DaliException e) {
72289       {
72290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72291       };
72292     } catch (...) {
72293       {
72294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72295       };
72296     }
72297   }
72298
72299   jresult = (void *)result;
72300   return jresult;
72301 }
72302
72303
72304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
72305   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72306   float arg2 ;
72307
72308   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72309   arg2 = (float)jarg2;
72310   if (arg1) (arg1)->min = arg2;
72311 }
72312
72313
72314 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
72315   float jresult ;
72316   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72317   float result;
72318
72319   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72320   result = (float) ((arg1)->min);
72321   jresult = result;
72322   return jresult;
72323 }
72324
72325
72326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
72327   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72328   float arg2 ;
72329
72330   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72331   arg2 = (float)jarg2;
72332   if (arg1) (arg1)->max = arg2;
72333 }
72334
72335
72336 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
72337   float jresult ;
72338   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72339   float result;
72340
72341   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72342   result = (float) ((arg1)->max);
72343   jresult = result;
72344   return jresult;
72345 }
72346
72347
72348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
72349   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72350   bool arg2 ;
72351
72352   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72353   arg2 = jarg2 ? true : false;
72354   if (arg1) (arg1)->enabled = arg2;
72355 }
72356
72357
72358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
72359   unsigned int jresult ;
72360   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72361   bool result;
72362
72363   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72364   result = (bool) ((arg1)->enabled);
72365   jresult = result;
72366   return jresult;
72367 }
72368
72369
72370 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72371   float jresult ;
72372   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72373   float arg2 ;
72374   float arg3 ;
72375   float arg4 ;
72376   float result;
72377
72378   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72379   arg2 = (float)jarg2;
72380   arg3 = (float)jarg3;
72381   arg4 = (float)jarg4;
72382   {
72383     try {
72384       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
72385     } catch (std::out_of_range& e) {
72386       {
72387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72388       };
72389     } catch (std::exception& e) {
72390       {
72391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72392       };
72393     } catch (Dali::DaliException e) {
72394       {
72395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72396       };
72397     } catch (...) {
72398       {
72399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72400       };
72401     }
72402   }
72403
72404   jresult = result;
72405   return jresult;
72406 }
72407
72408
72409 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72410   float jresult ;
72411   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72412   float arg2 ;
72413   float arg3 ;
72414   float result;
72415
72416   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72417   arg2 = (float)jarg2;
72418   arg3 = (float)jarg3;
72419   {
72420     try {
72421       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
72422     } catch (std::out_of_range& e) {
72423       {
72424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72425       };
72426     } catch (std::exception& e) {
72427       {
72428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72429       };
72430     } catch (Dali::DaliException e) {
72431       {
72432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72433       };
72434     } catch (...) {
72435       {
72436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72437       };
72438     }
72439   }
72440
72441   jresult = result;
72442   return jresult;
72443 }
72444
72445
72446 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
72447   float jresult ;
72448   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72449   float arg2 ;
72450   float result;
72451
72452   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72453   arg2 = (float)jarg2;
72454   {
72455     try {
72456       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
72457     } catch (std::out_of_range& e) {
72458       {
72459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72460       };
72461     } catch (std::exception& e) {
72462       {
72463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72464       };
72465     } catch (Dali::DaliException e) {
72466       {
72467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72468       };
72469     } catch (...) {
72470       {
72471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72472       };
72473     }
72474   }
72475
72476   jresult = result;
72477   return jresult;
72478 }
72479
72480
72481 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72482   float jresult ;
72483   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72484   float arg2 ;
72485   float arg3 ;
72486   float arg4 ;
72487   Dali::Toolkit::ClampState *arg5 = 0 ;
72488   float result;
72489
72490   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72491   arg2 = (float)jarg2;
72492   arg3 = (float)jarg3;
72493   arg4 = (float)jarg4;
72494   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72495   if (!arg5) {
72496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72497     return 0;
72498   }
72499   {
72500     try {
72501       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
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_GetSize(void * jarg1) {
72527   float jresult ;
72528   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72529   float result;
72530
72531   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72532   {
72533     try {
72534       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
72535     } catch (std::out_of_range& e) {
72536       {
72537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72538       };
72539     } catch (std::exception& e) {
72540       {
72541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72542       };
72543     } catch (Dali::DaliException e) {
72544       {
72545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72546       };
72547     } catch (...) {
72548       {
72549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72550       };
72551     }
72552   }
72553
72554   jresult = result;
72555   return jresult;
72556 }
72557
72558
72559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
72560   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72561
72562   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72563   {
72564     try {
72565       delete arg1;
72566     } catch (std::out_of_range& e) {
72567       {
72568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72569       };
72570     } catch (std::exception& e) {
72571       {
72572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72573       };
72574     } catch (Dali::DaliException e) {
72575       {
72576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72577       };
72578     } catch (...) {
72579       {
72580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72581       };
72582     }
72583   }
72584
72585 }
72586
72587
72588 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
72589   float jresult ;
72590   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72591   float arg2 ;
72592   float arg3 ;
72593   float result;
72594
72595   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72596   arg2 = (float)jarg2;
72597   arg3 = (float)jarg3;
72598   {
72599     try {
72600       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
72601     } catch (std::out_of_range& e) {
72602       {
72603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72604       };
72605     } catch (std::exception& e) {
72606       {
72607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72608       };
72609     } catch (Dali::DaliException e) {
72610       {
72611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72612       };
72613     } catch (...) {
72614       {
72615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72616       };
72617     }
72618   }
72619
72620   jresult = result;
72621   return jresult;
72622 }
72623
72624
72625 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
72626   float jresult ;
72627   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72628   float arg2 ;
72629   float result;
72630
72631   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72632   arg2 = (float)jarg2;
72633   {
72634     try {
72635       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
72636     } catch (std::out_of_range& e) {
72637       {
72638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72639       };
72640     } catch (std::exception& e) {
72641       {
72642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72643       };
72644     } catch (Dali::DaliException e) {
72645       {
72646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72647       };
72648     } catch (...) {
72649       {
72650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72651       };
72652     }
72653   }
72654
72655   jresult = result;
72656   return jresult;
72657 }
72658
72659
72660 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72661   float jresult ;
72662   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72663   unsigned int arg2 ;
72664   unsigned int *arg3 = 0 ;
72665   bool arg4 ;
72666   float result;
72667
72668   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72669   arg2 = (unsigned int)jarg2;
72670   arg3 = (unsigned int *)jarg3;
72671   arg4 = jarg4 ? true : false;
72672   {
72673     try {
72674       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72675     } catch (std::out_of_range& e) {
72676       {
72677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72678       };
72679     } catch (std::exception& e) {
72680       {
72681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72682       };
72683     } catch (Dali::DaliException e) {
72684       {
72685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72686       };
72687     } catch (...) {
72688       {
72689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72690       };
72691     }
72692   }
72693
72694   jresult = result;
72695   return jresult;
72696 }
72697
72698
72699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72700   unsigned int jresult ;
72701   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72702   float arg2 ;
72703   bool arg3 ;
72704   unsigned int result;
72705
72706   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72707   arg2 = (float)jarg2;
72708   arg3 = jarg3 ? true : false;
72709   {
72710     try {
72711       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
72712     } catch (std::out_of_range& e) {
72713       {
72714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72715       };
72716     } catch (std::exception& e) {
72717       {
72718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72719       };
72720     } catch (Dali::DaliException e) {
72721       {
72722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72723       };
72724     } catch (...) {
72725       {
72726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72727       };
72728     }
72729   }
72730
72731   jresult = result;
72732   return jresult;
72733 }
72734
72735
72736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
72737   unsigned int jresult ;
72738   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72739   unsigned int result;
72740
72741   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72742   {
72743     try {
72744       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
72745     } catch (std::out_of_range& e) {
72746       {
72747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72748       };
72749     } catch (std::exception& e) {
72750       {
72751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72752       };
72753     } catch (Dali::DaliException e) {
72754       {
72755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72756       };
72757     } catch (...) {
72758       {
72759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72760       };
72761     }
72762   }
72763
72764   jresult = result;
72765   return jresult;
72766 }
72767
72768
72769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
72770   int jresult ;
72771   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72772   Dali::Toolkit::Ruler::RulerType result;
72773
72774   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72775   {
72776     try {
72777       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
72778     } catch (std::out_of_range& e) {
72779       {
72780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72781       };
72782     } catch (std::exception& e) {
72783       {
72784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72785       };
72786     } catch (Dali::DaliException e) {
72787       {
72788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72789       };
72790     } catch (...) {
72791       {
72792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72793       };
72794     }
72795   }
72796
72797   jresult = (int)result;
72798   return jresult;
72799 }
72800
72801
72802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
72803   unsigned int jresult ;
72804   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72805   bool result;
72806
72807   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72808   {
72809     try {
72810       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
72811     } catch (std::out_of_range& e) {
72812       {
72813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72814       };
72815     } catch (std::exception& e) {
72816       {
72817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72818       };
72819     } catch (Dali::DaliException e) {
72820       {
72821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72822       };
72823     } catch (...) {
72824       {
72825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72826       };
72827     }
72828   }
72829
72830   jresult = result;
72831   return jresult;
72832 }
72833
72834
72835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
72836   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72837
72838   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72839   {
72840     try {
72841       (arg1)->Enable();
72842     } catch (std::out_of_range& e) {
72843       {
72844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72845       };
72846     } catch (std::exception& e) {
72847       {
72848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72849       };
72850     } catch (Dali::DaliException e) {
72851       {
72852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72853       };
72854     } catch (...) {
72855       {
72856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72857       };
72858     }
72859   }
72860
72861 }
72862
72863
72864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
72865   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72866
72867   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72868   {
72869     try {
72870       (arg1)->Disable();
72871     } catch (std::out_of_range& e) {
72872       {
72873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72874       };
72875     } catch (std::exception& e) {
72876       {
72877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72878       };
72879     } catch (Dali::DaliException e) {
72880       {
72881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72882       };
72883     } catch (...) {
72884       {
72885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72886       };
72887     }
72888   }
72889
72890 }
72891
72892
72893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
72894   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72895   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
72896   Dali::Toolkit::RulerDomain *argp2 ;
72897
72898   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72899   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
72900   if (!argp2) {
72901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
72902     return ;
72903   }
72904   arg2 = *argp2;
72905   {
72906     try {
72907       (arg1)->SetDomain(arg2);
72908     } catch (std::out_of_range& e) {
72909       {
72910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72911       };
72912     } catch (std::exception& e) {
72913       {
72914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72915       };
72916     } catch (Dali::DaliException e) {
72917       {
72918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72919       };
72920     } catch (...) {
72921       {
72922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72923       };
72924     }
72925   }
72926
72927 }
72928
72929
72930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
72931   void * jresult ;
72932   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72933   Dali::Toolkit::RulerDomain *result = 0 ;
72934
72935   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72936   {
72937     try {
72938       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
72939     } catch (std::out_of_range& e) {
72940       {
72941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72942       };
72943     } catch (std::exception& e) {
72944       {
72945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72946       };
72947     } catch (Dali::DaliException e) {
72948       {
72949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72950       };
72951     } catch (...) {
72952       {
72953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72954       };
72955     }
72956   }
72957
72958   jresult = (void *)result;
72959   return jresult;
72960 }
72961
72962
72963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
72964   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72965
72966   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72967   {
72968     try {
72969       (arg1)->DisableDomain();
72970     } catch (std::out_of_range& e) {
72971       {
72972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72973       };
72974     } catch (std::exception& e) {
72975       {
72976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72977       };
72978     } catch (Dali::DaliException e) {
72979       {
72980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72981       };
72982     } catch (...) {
72983       {
72984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72985       };
72986     }
72987   }
72988
72989 }
72990
72991
72992 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72993   float jresult ;
72994   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72995   float arg2 ;
72996   float arg3 ;
72997   float arg4 ;
72998   float result;
72999
73000   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73001   arg2 = (float)jarg2;
73002   arg3 = (float)jarg3;
73003   arg4 = (float)jarg4;
73004   {
73005     try {
73006       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
73007     } catch (std::out_of_range& e) {
73008       {
73009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73010       };
73011     } catch (std::exception& e) {
73012       {
73013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73014       };
73015     } catch (Dali::DaliException e) {
73016       {
73017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73018       };
73019     } catch (...) {
73020       {
73021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73022       };
73023     }
73024   }
73025
73026   jresult = result;
73027   return jresult;
73028 }
73029
73030
73031 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
73032   float jresult ;
73033   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73034   float arg2 ;
73035   float arg3 ;
73036   float result;
73037
73038   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73039   arg2 = (float)jarg2;
73040   arg3 = (float)jarg3;
73041   {
73042     try {
73043       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
73044     } catch (std::out_of_range& e) {
73045       {
73046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73047       };
73048     } catch (std::exception& e) {
73049       {
73050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73051       };
73052     } catch (Dali::DaliException e) {
73053       {
73054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73055       };
73056     } catch (...) {
73057       {
73058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73059       };
73060     }
73061   }
73062
73063   jresult = result;
73064   return jresult;
73065 }
73066
73067
73068 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
73069   float jresult ;
73070   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73071   float arg2 ;
73072   float result;
73073
73074   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73075   arg2 = (float)jarg2;
73076   {
73077     try {
73078       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
73079     } catch (std::out_of_range& e) {
73080       {
73081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73082       };
73083     } catch (std::exception& e) {
73084       {
73085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73086       };
73087     } catch (Dali::DaliException e) {
73088       {
73089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73090       };
73091     } catch (...) {
73092       {
73093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73094       };
73095     }
73096   }
73097
73098   jresult = result;
73099   return jresult;
73100 }
73101
73102
73103 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
73104   float jresult ;
73105   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73106   float arg2 ;
73107   float arg3 ;
73108   float arg4 ;
73109   Dali::Toolkit::ClampState *arg5 = 0 ;
73110   float result;
73111
73112   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73113   arg2 = (float)jarg2;
73114   arg3 = (float)jarg3;
73115   arg4 = (float)jarg4;
73116   arg5 = (Dali::Toolkit::ClampState *)jarg5;
73117   if (!arg5) {
73118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73119     return 0;
73120   }
73121   {
73122     try {
73123       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
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_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
73149   float jresult ;
73150   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73151   float arg2 ;
73152   float arg3 ;
73153   float arg4 ;
73154   float arg5 ;
73155   float result;
73156
73157   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73158   arg2 = (float)jarg2;
73159   arg3 = (float)jarg3;
73160   arg4 = (float)jarg4;
73161   arg5 = (float)jarg5;
73162   {
73163     try {
73164       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
73165     } catch (std::out_of_range& e) {
73166       {
73167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73168       };
73169     } catch (std::exception& e) {
73170       {
73171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73172       };
73173     } catch (Dali::DaliException e) {
73174       {
73175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73176       };
73177     } catch (...) {
73178       {
73179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73180       };
73181     }
73182   }
73183
73184   jresult = result;
73185   return jresult;
73186 }
73187
73188
73189 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
73190   float jresult ;
73191   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73192   float arg2 ;
73193   float arg3 ;
73194   float arg4 ;
73195   float result;
73196
73197   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73198   arg2 = (float)jarg2;
73199   arg3 = (float)jarg3;
73200   arg4 = (float)jarg4;
73201   {
73202     try {
73203       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
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_2(void * jarg1, float jarg2, float jarg3) {
73229   float jresult ;
73230   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73231   float arg2 ;
73232   float arg3 ;
73233   float result;
73234
73235   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73236   arg2 = (float)jarg2;
73237   arg3 = (float)jarg3;
73238   {
73239     try {
73240       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
73241     } catch (std::out_of_range& e) {
73242       {
73243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73244       };
73245     } catch (std::exception& e) {
73246       {
73247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73248       };
73249     } catch (Dali::DaliException e) {
73250       {
73251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73252       };
73253     } catch (...) {
73254       {
73255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73256       };
73257     }
73258   }
73259
73260   jresult = result;
73261   return jresult;
73262 }
73263
73264
73265 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
73266   float jresult ;
73267   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73268   float arg2 ;
73269   float result;
73270
73271   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73272   arg2 = (float)jarg2;
73273   {
73274     try {
73275       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
73276     } catch (std::out_of_range& e) {
73277       {
73278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73279       };
73280     } catch (std::exception& e) {
73281       {
73282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73283       };
73284     } catch (Dali::DaliException e) {
73285       {
73286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73287       };
73288     } catch (...) {
73289       {
73290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73291       };
73292     }
73293   }
73294
73295   jresult = result;
73296   return jresult;
73297 }
73298
73299
73300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
73301   float jresult ;
73302   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73303   float arg2 ;
73304   float arg3 ;
73305   float arg4 ;
73306   float arg5 ;
73307   Dali::Toolkit::ClampState *arg6 = 0 ;
73308   float result;
73309
73310   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73311   arg2 = (float)jarg2;
73312   arg3 = (float)jarg3;
73313   arg4 = (float)jarg4;
73314   arg5 = (float)jarg5;
73315   arg6 = (Dali::Toolkit::ClampState *)jarg6;
73316   if (!arg6) {
73317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73318     return 0;
73319   }
73320   {
73321     try {
73322       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
73323     } catch (std::out_of_range& e) {
73324       {
73325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73326       };
73327     } catch (std::exception& e) {
73328       {
73329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73330       };
73331     } catch (Dali::DaliException e) {
73332       {
73333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73334       };
73335     } catch (...) {
73336       {
73337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73338       };
73339     }
73340   }
73341
73342   jresult = result;
73343   return jresult;
73344 }
73345
73346
73347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
73348   void * jresult ;
73349   Dali::Toolkit::DefaultRuler *result = 0 ;
73350
73351   {
73352     try {
73353       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
73354     } catch (std::out_of_range& e) {
73355       {
73356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73357       };
73358     } catch (std::exception& e) {
73359       {
73360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73361       };
73362     } catch (Dali::DaliException e) {
73363       {
73364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73365       };
73366     } catch (...) {
73367       {
73368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73369       };
73370     }
73371   }
73372
73373   jresult = (void *)result;
73374   return jresult;
73375 }
73376
73377
73378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73379   float jresult ;
73380   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73381   float arg2 ;
73382   float arg3 ;
73383   float result;
73384
73385   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73386   arg2 = (float)jarg2;
73387   arg3 = (float)jarg3;
73388   {
73389     try {
73390       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
73391     } catch (std::out_of_range& e) {
73392       {
73393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73394       };
73395     } catch (std::exception& e) {
73396       {
73397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73398       };
73399     } catch (Dali::DaliException e) {
73400       {
73401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73402       };
73403     } catch (...) {
73404       {
73405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73406       };
73407     }
73408   }
73409
73410   jresult = result;
73411   return jresult;
73412 }
73413
73414
73415 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73416   float jresult ;
73417   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73418   unsigned int arg2 ;
73419   unsigned int *arg3 = 0 ;
73420   bool arg4 ;
73421   float result;
73422
73423   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73424   arg2 = (unsigned int)jarg2;
73425   arg3 = (unsigned int *)jarg3;
73426   arg4 = jarg4 ? true : false;
73427   {
73428     try {
73429       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73430     } catch (std::out_of_range& e) {
73431       {
73432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73433       };
73434     } catch (std::exception& e) {
73435       {
73436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73437       };
73438     } catch (Dali::DaliException e) {
73439       {
73440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73441       };
73442     } catch (...) {
73443       {
73444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73445       };
73446     }
73447   }
73448
73449   jresult = result;
73450   return jresult;
73451 }
73452
73453
73454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73455   unsigned int jresult ;
73456   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73457   float arg2 ;
73458   bool arg3 ;
73459   unsigned int result;
73460
73461   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73462   arg2 = (float)jarg2;
73463   arg3 = jarg3 ? true : false;
73464   {
73465     try {
73466       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73467     } catch (std::out_of_range& e) {
73468       {
73469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73470       };
73471     } catch (std::exception& e) {
73472       {
73473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73474       };
73475     } catch (Dali::DaliException e) {
73476       {
73477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73478       };
73479     } catch (...) {
73480       {
73481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73482       };
73483     }
73484   }
73485
73486   jresult = result;
73487   return jresult;
73488 }
73489
73490
73491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
73492   unsigned int jresult ;
73493   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73494   unsigned int result;
73495
73496   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73497   {
73498     try {
73499       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
73500     } catch (std::out_of_range& e) {
73501       {
73502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73503       };
73504     } catch (std::exception& e) {
73505       {
73506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73507       };
73508     } catch (Dali::DaliException e) {
73509       {
73510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73511       };
73512     } catch (...) {
73513       {
73514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73515       };
73516     }
73517   }
73518
73519   jresult = result;
73520   return jresult;
73521 }
73522
73523
73524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
73525   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73526
73527   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73528   {
73529     try {
73530       delete arg1;
73531     } catch (std::out_of_range& e) {
73532       {
73533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73534       };
73535     } catch (std::exception& e) {
73536       {
73537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73538       };
73539     } catch (Dali::DaliException e) {
73540       {
73541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73542       };
73543     } catch (...) {
73544       {
73545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73546       };
73547     }
73548   }
73549
73550 }
73551
73552
73553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
73554   void * jresult ;
73555   float arg1 ;
73556   Dali::Toolkit::FixedRuler *result = 0 ;
73557
73558   arg1 = (float)jarg1;
73559   {
73560     try {
73561       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
73562     } catch (std::out_of_range& e) {
73563       {
73564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73565       };
73566     } catch (std::exception& e) {
73567       {
73568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73569       };
73570     } catch (Dali::DaliException e) {
73571       {
73572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73573       };
73574     } catch (...) {
73575       {
73576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73577       };
73578     }
73579   }
73580
73581   jresult = (void *)result;
73582   return jresult;
73583 }
73584
73585
73586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
73587   void * jresult ;
73588   Dali::Toolkit::FixedRuler *result = 0 ;
73589
73590   {
73591     try {
73592       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
73593     } catch (std::out_of_range& e) {
73594       {
73595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73596       };
73597     } catch (std::exception& e) {
73598       {
73599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73600       };
73601     } catch (Dali::DaliException e) {
73602       {
73603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73604       };
73605     } catch (...) {
73606       {
73607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73608       };
73609     }
73610   }
73611
73612   jresult = (void *)result;
73613   return jresult;
73614 }
73615
73616
73617 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73618   float jresult ;
73619   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73620   float arg2 ;
73621   float arg3 ;
73622   float result;
73623
73624   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73625   arg2 = (float)jarg2;
73626   arg3 = (float)jarg3;
73627   {
73628     try {
73629       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
73630     } catch (std::out_of_range& e) {
73631       {
73632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73633       };
73634     } catch (std::exception& e) {
73635       {
73636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73637       };
73638     } catch (Dali::DaliException e) {
73639       {
73640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73641       };
73642     } catch (...) {
73643       {
73644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73645       };
73646     }
73647   }
73648
73649   jresult = result;
73650   return jresult;
73651 }
73652
73653
73654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73655   float jresult ;
73656   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73657   unsigned int arg2 ;
73658   unsigned int *arg3 = 0 ;
73659   bool arg4 ;
73660   float result;
73661
73662   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73663   arg2 = (unsigned int)jarg2;
73664   arg3 = (unsigned int *)jarg3;
73665   arg4 = jarg4 ? true : false;
73666   {
73667     try {
73668       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73669     } catch (std::out_of_range& e) {
73670       {
73671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73672       };
73673     } catch (std::exception& e) {
73674       {
73675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73676       };
73677     } catch (Dali::DaliException e) {
73678       {
73679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73680       };
73681     } catch (...) {
73682       {
73683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73684       };
73685     }
73686   }
73687
73688   jresult = result;
73689   return jresult;
73690 }
73691
73692
73693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73694   unsigned int jresult ;
73695   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73696   float arg2 ;
73697   bool arg3 ;
73698   unsigned int result;
73699
73700   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73701   arg2 = (float)jarg2;
73702   arg3 = jarg3 ? true : false;
73703   {
73704     try {
73705       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73706     } catch (std::out_of_range& e) {
73707       {
73708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73709       };
73710     } catch (std::exception& e) {
73711       {
73712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73713       };
73714     } catch (Dali::DaliException e) {
73715       {
73716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73717       };
73718     } catch (...) {
73719       {
73720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73721       };
73722     }
73723   }
73724
73725   jresult = result;
73726   return jresult;
73727 }
73728
73729
73730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
73731   unsigned int jresult ;
73732   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73733   unsigned int result;
73734
73735   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73736   {
73737     try {
73738       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
73739     } catch (std::out_of_range& e) {
73740       {
73741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73742       };
73743     } catch (std::exception& e) {
73744       {
73745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73746       };
73747     } catch (Dali::DaliException e) {
73748       {
73749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73750       };
73751     } catch (...) {
73752       {
73753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73754       };
73755     }
73756   }
73757
73758   jresult = result;
73759   return jresult;
73760 }
73761
73762
73763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
73764   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73765
73766   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73767   {
73768     try {
73769       delete arg1;
73770     } catch (std::out_of_range& e) {
73771       {
73772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73773       };
73774     } catch (std::exception& e) {
73775       {
73776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73777       };
73778     } catch (Dali::DaliException e) {
73779       {
73780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73781       };
73782     } catch (...) {
73783       {
73784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73785       };
73786     }
73787   }
73788
73789 }
73790
73791
73792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
73793   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73794   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73795
73796   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73797   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73798   if (arg1) (arg1)->scale = *arg2;
73799 }
73800
73801
73802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
73803   void * jresult ;
73804   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73805   Dali::Toolkit::ClampState2D *result = 0 ;
73806
73807   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73808   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
73809   jresult = (void *)result;
73810   return jresult;
73811 }
73812
73813
73814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
73815   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73816   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73817
73818   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73819   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73820   if (arg1) (arg1)->position = *arg2;
73821 }
73822
73823
73824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
73825   void * jresult ;
73826   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73827   Dali::Toolkit::ClampState2D *result = 0 ;
73828
73829   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73830   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
73831   jresult = (void *)result;
73832   return jresult;
73833 }
73834
73835
73836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
73837   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73838   Dali::Toolkit::ClampState arg2 ;
73839
73840   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73841   arg2 = (Dali::Toolkit::ClampState)jarg2;
73842   if (arg1) (arg1)->rotation = arg2;
73843 }
73844
73845
73846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
73847   int jresult ;
73848   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73849   Dali::Toolkit::ClampState result;
73850
73851   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73852   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
73853   jresult = (int)result;
73854   return jresult;
73855 }
73856
73857
73858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
73859   void * jresult ;
73860   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
73861
73862   {
73863     try {
73864       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
73865     } catch (std::out_of_range& e) {
73866       {
73867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73868       };
73869     } catch (std::exception& e) {
73870       {
73871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73872       };
73873     } catch (Dali::DaliException e) {
73874       {
73875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73876       };
73877     } catch (...) {
73878       {
73879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73880       };
73881     }
73882   }
73883
73884   jresult = (void *)result;
73885   return jresult;
73886 }
73887
73888
73889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
73890   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73891
73892   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73893   {
73894     try {
73895       delete arg1;
73896     } catch (std::out_of_range& e) {
73897       {
73898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73899       };
73900     } catch (std::exception& e) {
73901       {
73902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73903       };
73904     } catch (Dali::DaliException e) {
73905       {
73906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73907       };
73908     } catch (...) {
73909       {
73910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73911       };
73912     }
73913   }
73914
73915 }
73916
73917
73918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
73919   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73920   Dali::Toolkit::SnapType arg2 ;
73921
73922   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73923   arg2 = (Dali::Toolkit::SnapType)jarg2;
73924   if (arg1) (arg1)->type = arg2;
73925 }
73926
73927
73928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
73929   int jresult ;
73930   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73931   Dali::Toolkit::SnapType result;
73932
73933   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73934   result = (Dali::Toolkit::SnapType) ((arg1)->type);
73935   jresult = (int)result;
73936   return jresult;
73937 }
73938
73939
73940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
73941   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73942   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
73943
73944   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73945   arg2 = (Dali::Vector2 *)jarg2;
73946   if (arg1) (arg1)->position = *arg2;
73947 }
73948
73949
73950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
73951   void * jresult ;
73952   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73953   Dali::Vector2 *result = 0 ;
73954
73955   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73956   result = (Dali::Vector2 *)& ((arg1)->position);
73957   jresult = (void *)result;
73958   return jresult;
73959 }
73960
73961
73962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
73963   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73964   float arg2 ;
73965
73966   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73967   arg2 = (float)jarg2;
73968   if (arg1) (arg1)->duration = arg2;
73969 }
73970
73971
73972 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
73973   float jresult ;
73974   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73975   float result;
73976
73977   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73978   result = (float) ((arg1)->duration);
73979   jresult = result;
73980   return jresult;
73981 }
73982
73983
73984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
73985   void * jresult ;
73986   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
73987
73988   {
73989     try {
73990       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
73991     } catch (std::out_of_range& e) {
73992       {
73993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73994       };
73995     } catch (std::exception& e) {
73996       {
73997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73998       };
73999     } catch (Dali::DaliException e) {
74000       {
74001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74002       };
74003     } catch (...) {
74004       {
74005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74006       };
74007     }
74008   }
74009
74010   jresult = (void *)result;
74011   return jresult;
74012 }
74013
74014
74015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
74016   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74017
74018   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74019   {
74020     try {
74021       delete arg1;
74022     } catch (std::out_of_range& e) {
74023       {
74024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74025       };
74026     } catch (std::exception& e) {
74027       {
74028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74029       };
74030     } catch (Dali::DaliException e) {
74031       {
74032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74033       };
74034     } catch (...) {
74035       {
74036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74037       };
74038     }
74039   }
74040
74041 }
74042
74043
74044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
74045   int jresult ;
74046   int result;
74047
74048   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
74049   jresult = (int)result;
74050   return jresult;
74051 }
74052
74053
74054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
74055   int jresult ;
74056   int result;
74057
74058   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
74059   jresult = (int)result;
74060   return jresult;
74061 }
74062
74063
74064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
74065   int jresult ;
74066   int result;
74067
74068   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
74069   jresult = (int)result;
74070   return jresult;
74071 }
74072
74073
74074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74075   int jresult ;
74076   int result;
74077
74078   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74079   jresult = (int)result;
74080   return jresult;
74081 }
74082
74083
74084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
74085   int jresult ;
74086   int result;
74087
74088   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
74089   jresult = (int)result;
74090   return jresult;
74091 }
74092
74093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
74094   int jresult ;
74095   int result;
74096
74097   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
74098   jresult = (int)result;
74099   return jresult;
74100 }
74101
74102
74103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
74104   int jresult ;
74105   int result;
74106
74107   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
74108   jresult = (int)result;
74109   return jresult;
74110 }
74111
74112
74113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
74114   int jresult ;
74115   int result;
74116
74117   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
74118   jresult = (int)result;
74119   return jresult;
74120 }
74121
74122
74123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
74124   int jresult ;
74125   int result;
74126
74127   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
74128   jresult = (int)result;
74129   return jresult;
74130 }
74131
74132
74133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
74134   int jresult ;
74135   int result;
74136
74137   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
74138   jresult = (int)result;
74139   return jresult;
74140 }
74141
74142
74143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
74144   int jresult ;
74145   int result;
74146
74147   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
74148   jresult = (int)result;
74149   return jresult;
74150 }
74151
74152
74153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
74154   int jresult ;
74155   int result;
74156
74157   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
74158   jresult = (int)result;
74159   return jresult;
74160 }
74161
74162
74163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
74164   int jresult ;
74165   int result;
74166
74167   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
74168   jresult = (int)result;
74169   return jresult;
74170 }
74171
74172
74173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
74174   int jresult ;
74175   int result;
74176
74177   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
74178   jresult = (int)result;
74179   return jresult;
74180 }
74181
74182
74183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
74184   int jresult ;
74185   int result;
74186
74187   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
74188   jresult = (int)result;
74189   return jresult;
74190 }
74191
74192
74193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
74194   int jresult ;
74195   int result;
74196
74197   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
74198   jresult = (int)result;
74199   return jresult;
74200 }
74201
74202
74203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
74204   int jresult ;
74205   int result;
74206
74207   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
74208   jresult = (int)result;
74209   return jresult;
74210 }
74211
74212
74213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
74214   int jresult ;
74215   int result;
74216
74217   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
74218   jresult = (int)result;
74219   return jresult;
74220 }
74221
74222
74223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
74224   int jresult ;
74225   int result;
74226
74227   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
74228   jresult = (int)result;
74229   return jresult;
74230 }
74231
74232
74233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
74234   int jresult ;
74235   int result;
74236
74237   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
74238   jresult = (int)result;
74239   return jresult;
74240 }
74241
74242
74243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
74244   int jresult ;
74245   int result;
74246
74247   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
74248   jresult = (int)result;
74249   return jresult;
74250 }
74251
74252
74253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
74254   int jresult ;
74255   int result;
74256
74257   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
74258   jresult = (int)result;
74259   return jresult;
74260 }
74261
74262
74263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
74264   int jresult ;
74265   int result;
74266
74267   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
74268   jresult = (int)result;
74269   return jresult;
74270 }
74271
74272
74273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
74274   int jresult ;
74275   int result;
74276
74277   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
74278   jresult = (int)result;
74279   return jresult;
74280 }
74281
74282
74283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
74284   int jresult ;
74285   int result;
74286
74287   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
74288   jresult = (int)result;
74289   return jresult;
74290 }
74291
74292
74293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
74294   int jresult ;
74295   int result;
74296
74297   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
74298   jresult = (int)result;
74299   return jresult;
74300 }
74301
74302
74303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
74304   void * jresult ;
74305   Dali::Toolkit::ScrollView::Property *result = 0 ;
74306
74307   {
74308     try {
74309       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
74310     } catch (std::out_of_range& e) {
74311       {
74312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74313       };
74314     } catch (std::exception& e) {
74315       {
74316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74317       };
74318     } catch (Dali::DaliException e) {
74319       {
74320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74321       };
74322     } catch (...) {
74323       {
74324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74325       };
74326     }
74327   }
74328
74329   jresult = (void *)result;
74330   return jresult;
74331 }
74332
74333
74334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
74335   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
74336
74337   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
74338   {
74339     try {
74340       delete arg1;
74341     } catch (std::out_of_range& e) {
74342       {
74343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74344       };
74345     } catch (std::exception& e) {
74346       {
74347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74348       };
74349     } catch (Dali::DaliException e) {
74350       {
74351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74352       };
74353     } catch (...) {
74354       {
74355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74356       };
74357     }
74358   }
74359
74360 }
74361
74362
74363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
74364   void * jresult ;
74365   Dali::Toolkit::ScrollView *result = 0 ;
74366
74367   {
74368     try {
74369       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
74370     } catch (std::out_of_range& e) {
74371       {
74372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74373       };
74374     } catch (std::exception& e) {
74375       {
74376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74377       };
74378     } catch (Dali::DaliException e) {
74379       {
74380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74381       };
74382     } catch (...) {
74383       {
74384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74385       };
74386     }
74387   }
74388
74389   jresult = (void *)result;
74390   return jresult;
74391 }
74392
74393
74394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
74395   void * jresult ;
74396   Dali::Toolkit::ScrollView *arg1 = 0 ;
74397   Dali::Toolkit::ScrollView *result = 0 ;
74398
74399   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74400   if (!arg1) {
74401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74402     return 0;
74403   }
74404   {
74405     try {
74406       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
74407     } catch (std::out_of_range& e) {
74408       {
74409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74410       };
74411     } catch (std::exception& e) {
74412       {
74413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74414       };
74415     } catch (Dali::DaliException e) {
74416       {
74417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74418       };
74419     } catch (...) {
74420       {
74421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74422       };
74423     }
74424   }
74425
74426   jresult = (void *)result;
74427   return jresult;
74428 }
74429
74430
74431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
74432   void * jresult ;
74433   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74434   Dali::Toolkit::ScrollView *arg2 = 0 ;
74435   Dali::Toolkit::ScrollView *result = 0 ;
74436
74437   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74438   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
74439   if (!arg2) {
74440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74441     return 0;
74442   }
74443   {
74444     try {
74445       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
74446     } catch (std::out_of_range& e) {
74447       {
74448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74449       };
74450     } catch (std::exception& e) {
74451       {
74452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74453       };
74454     } catch (Dali::DaliException e) {
74455       {
74456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74457       };
74458     } catch (...) {
74459       {
74460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74461       };
74462     }
74463   }
74464
74465   jresult = (void *)result;
74466   return jresult;
74467 }
74468
74469
74470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
74471   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74472
74473   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74474   {
74475     try {
74476       delete arg1;
74477     } catch (std::out_of_range& e) {
74478       {
74479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74480       };
74481     } catch (std::exception& e) {
74482       {
74483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74484       };
74485     } catch (Dali::DaliException e) {
74486       {
74487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74488       };
74489     } catch (...) {
74490       {
74491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74492       };
74493     }
74494   }
74495
74496 }
74497
74498
74499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
74500   void * jresult ;
74501   Dali::Toolkit::ScrollView result;
74502
74503   {
74504     try {
74505       result = Dali::Toolkit::ScrollView::New();
74506     } catch (std::out_of_range& e) {
74507       {
74508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74509       };
74510     } catch (std::exception& e) {
74511       {
74512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74513       };
74514     } catch (Dali::DaliException e) {
74515       {
74516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74517       };
74518     } catch (...) {
74519       {
74520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74521       };
74522     }
74523   }
74524
74525   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74526   return jresult;
74527 }
74528
74529
74530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
74531   void * jresult ;
74532   Dali::BaseHandle arg1 ;
74533   Dali::BaseHandle *argp1 ;
74534   Dali::Toolkit::ScrollView result;
74535
74536   argp1 = (Dali::BaseHandle *)jarg1;
74537   if (!argp1) {
74538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74539     return 0;
74540   }
74541   arg1 = *argp1;
74542   {
74543     try {
74544       result = Dali::Toolkit::ScrollView::DownCast(arg1);
74545     } catch (std::out_of_range& e) {
74546       {
74547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74548       };
74549     } catch (std::exception& e) {
74550       {
74551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74552       };
74553     } catch (Dali::DaliException e) {
74554       {
74555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74556       };
74557     } catch (...) {
74558       {
74559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74560       };
74561     }
74562   }
74563
74564   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74565   return jresult;
74566 }
74567
74568
74569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
74570   void * jresult ;
74571   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74572   Dali::AlphaFunction result;
74573
74574   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74575   {
74576     try {
74577       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
74578     } catch (std::out_of_range& e) {
74579       {
74580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74581       };
74582     } catch (std::exception& e) {
74583       {
74584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74585       };
74586     } catch (Dali::DaliException e) {
74587       {
74588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74589       };
74590     } catch (...) {
74591       {
74592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74593       };
74594     }
74595   }
74596
74597   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74598   return jresult;
74599 }
74600
74601
74602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
74603   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74604   Dali::AlphaFunction arg2 ;
74605   Dali::AlphaFunction *argp2 ;
74606
74607   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74608   argp2 = (Dali::AlphaFunction *)jarg2;
74609   if (!argp2) {
74610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74611     return ;
74612   }
74613   arg2 = *argp2;
74614   {
74615     try {
74616       (arg1)->SetScrollSnapAlphaFunction(arg2);
74617     } catch (std::out_of_range& e) {
74618       {
74619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74620       };
74621     } catch (std::exception& e) {
74622       {
74623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74624       };
74625     } catch (Dali::DaliException e) {
74626       {
74627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74628       };
74629     } catch (...) {
74630       {
74631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74632       };
74633     }
74634   }
74635
74636 }
74637
74638
74639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
74640   void * jresult ;
74641   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74642   Dali::AlphaFunction result;
74643
74644   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74645   {
74646     try {
74647       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
74648     } catch (std::out_of_range& e) {
74649       {
74650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74651       };
74652     } catch (std::exception& e) {
74653       {
74654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74655       };
74656     } catch (Dali::DaliException e) {
74657       {
74658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74659       };
74660     } catch (...) {
74661       {
74662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74663       };
74664     }
74665   }
74666
74667   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74668   return jresult;
74669 }
74670
74671
74672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
74673   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74674   Dali::AlphaFunction arg2 ;
74675   Dali::AlphaFunction *argp2 ;
74676
74677   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74678   argp2 = (Dali::AlphaFunction *)jarg2;
74679   if (!argp2) {
74680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74681     return ;
74682   }
74683   arg2 = *argp2;
74684   {
74685     try {
74686       (arg1)->SetScrollFlickAlphaFunction(arg2);
74687     } catch (std::out_of_range& e) {
74688       {
74689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74690       };
74691     } catch (std::exception& e) {
74692       {
74693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74694       };
74695     } catch (Dali::DaliException e) {
74696       {
74697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74698       };
74699     } catch (...) {
74700       {
74701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74702       };
74703     }
74704   }
74705
74706 }
74707
74708
74709 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
74710   float jresult ;
74711   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74712   float result;
74713
74714   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74715   {
74716     try {
74717       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
74718     } catch (std::out_of_range& e) {
74719       {
74720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74721       };
74722     } catch (std::exception& e) {
74723       {
74724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74725       };
74726     } catch (Dali::DaliException e) {
74727       {
74728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74729       };
74730     } catch (...) {
74731       {
74732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74733       };
74734     }
74735   }
74736
74737   jresult = result;
74738   return jresult;
74739 }
74740
74741
74742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
74743   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74744   float arg2 ;
74745
74746   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74747   arg2 = (float)jarg2;
74748   {
74749     try {
74750       (arg1)->SetScrollSnapDuration(arg2);
74751     } catch (std::out_of_range& e) {
74752       {
74753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74754       };
74755     } catch (std::exception& e) {
74756       {
74757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74758       };
74759     } catch (Dali::DaliException e) {
74760       {
74761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74762       };
74763     } catch (...) {
74764       {
74765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74766       };
74767     }
74768   }
74769
74770 }
74771
74772
74773 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
74774   float jresult ;
74775   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74776   float result;
74777
74778   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74779   {
74780     try {
74781       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
74782     } catch (std::out_of_range& e) {
74783       {
74784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74785       };
74786     } catch (std::exception& e) {
74787       {
74788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74789       };
74790     } catch (Dali::DaliException e) {
74791       {
74792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74793       };
74794     } catch (...) {
74795       {
74796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74797       };
74798     }
74799   }
74800
74801   jresult = result;
74802   return jresult;
74803 }
74804
74805
74806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
74807   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74808   float arg2 ;
74809
74810   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74811   arg2 = (float)jarg2;
74812   {
74813     try {
74814       (arg1)->SetScrollFlickDuration(arg2);
74815     } catch (std::out_of_range& e) {
74816       {
74817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74818       };
74819     } catch (std::exception& e) {
74820       {
74821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74822       };
74823     } catch (Dali::DaliException e) {
74824       {
74825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74826       };
74827     } catch (...) {
74828       {
74829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74830       };
74831     }
74832   }
74833
74834 }
74835
74836
74837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
74838   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74839   Dali::Toolkit::RulerPtr arg2 ;
74840   Dali::Toolkit::RulerPtr *argp2 ;
74841
74842   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74843   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74844   if (!argp2) {
74845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74846     return ;
74847   }
74848   arg2 = *argp2;
74849   {
74850     try {
74851       (arg1)->SetRulerX(arg2);
74852     } catch (std::out_of_range& e) {
74853       {
74854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74855       };
74856     } catch (std::exception& e) {
74857       {
74858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74859       };
74860     } catch (Dali::DaliException e) {
74861       {
74862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74863       };
74864     } catch (...) {
74865       {
74866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74867       };
74868     }
74869   }
74870
74871 }
74872
74873
74874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
74875   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74876   Dali::Toolkit::RulerPtr arg2 ;
74877   Dali::Toolkit::RulerPtr *argp2 ;
74878
74879   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74880   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74881   if (!argp2) {
74882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74883     return ;
74884   }
74885   arg2 = *argp2;
74886   {
74887     try {
74888       (arg1)->SetRulerY(arg2);
74889     } catch (std::out_of_range& e) {
74890       {
74891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74892       };
74893     } catch (std::exception& e) {
74894       {
74895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74896       };
74897     } catch (Dali::DaliException e) {
74898       {
74899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74900       };
74901     } catch (...) {
74902       {
74903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74904       };
74905     }
74906   }
74907
74908 }
74909
74910
74911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
74912   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74913   bool arg2 ;
74914
74915   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74916   arg2 = jarg2 ? true : false;
74917   {
74918     try {
74919       (arg1)->SetScrollSensitive(arg2);
74920     } catch (std::out_of_range& e) {
74921       {
74922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74923       };
74924     } catch (std::exception& e) {
74925       {
74926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74927       };
74928     } catch (Dali::DaliException e) {
74929       {
74930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74931       };
74932     } catch (...) {
74933       {
74934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74935       };
74936     }
74937   }
74938
74939 }
74940
74941
74942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
74943   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74944   float arg2 ;
74945   float arg3 ;
74946
74947   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74948   arg2 = (float)jarg2;
74949   arg3 = (float)jarg3;
74950   {
74951     try {
74952       (arg1)->SetMaxOvershoot(arg2,arg3);
74953     } catch (std::out_of_range& e) {
74954       {
74955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74956       };
74957     } catch (std::exception& e) {
74958       {
74959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74960       };
74961     } catch (Dali::DaliException e) {
74962       {
74963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74964       };
74965     } catch (...) {
74966       {
74967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74968       };
74969     }
74970   }
74971
74972 }
74973
74974
74975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
74976   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74977   Dali::AlphaFunction arg2 ;
74978   Dali::AlphaFunction *argp2 ;
74979
74980   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74981   argp2 = (Dali::AlphaFunction *)jarg2;
74982   if (!argp2) {
74983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74984     return ;
74985   }
74986   arg2 = *argp2;
74987   {
74988     try {
74989       (arg1)->SetSnapOvershootAlphaFunction(arg2);
74990     } catch (std::out_of_range& e) {
74991       {
74992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74993       };
74994     } catch (std::exception& e) {
74995       {
74996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74997       };
74998     } catch (Dali::DaliException e) {
74999       {
75000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75001       };
75002     } catch (...) {
75003       {
75004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75005       };
75006     }
75007   }
75008
75009 }
75010
75011
75012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
75013   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75014   float arg2 ;
75015
75016   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75017   arg2 = (float)jarg2;
75018   {
75019     try {
75020       (arg1)->SetSnapOvershootDuration(arg2);
75021     } catch (std::out_of_range& e) {
75022       {
75023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75024       };
75025     } catch (std::exception& e) {
75026       {
75027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75028       };
75029     } catch (Dali::DaliException e) {
75030       {
75031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75032       };
75033     } catch (...) {
75034       {
75035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75036       };
75037     }
75038   }
75039
75040 }
75041
75042
75043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
75044   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75045   bool arg2 ;
75046
75047   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75048   arg2 = jarg2 ? true : false;
75049   {
75050     try {
75051       (arg1)->SetActorAutoSnap(arg2);
75052     } catch (std::out_of_range& e) {
75053       {
75054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75055       };
75056     } catch (std::exception& e) {
75057       {
75058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75059       };
75060     } catch (Dali::DaliException e) {
75061       {
75062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75063       };
75064     } catch (...) {
75065       {
75066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75067       };
75068     }
75069   }
75070
75071 }
75072
75073
75074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
75075   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75076   bool arg2 ;
75077
75078   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75079   arg2 = jarg2 ? true : false;
75080   {
75081     try {
75082       (arg1)->SetWrapMode(arg2);
75083     } catch (std::out_of_range& e) {
75084       {
75085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75086       };
75087     } catch (std::exception& e) {
75088       {
75089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75090       };
75091     } catch (Dali::DaliException e) {
75092       {
75093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75094       };
75095     } catch (...) {
75096       {
75097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75098       };
75099     }
75100   }
75101
75102 }
75103
75104
75105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
75106   int jresult ;
75107   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75108   int result;
75109
75110   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75111   {
75112     try {
75113       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
75114     } catch (std::out_of_range& e) {
75115       {
75116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75117       };
75118     } catch (std::exception& e) {
75119       {
75120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75121       };
75122     } catch (Dali::DaliException e) {
75123       {
75124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75125       };
75126     } catch (...) {
75127       {
75128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75129       };
75130     }
75131   }
75132
75133   jresult = result;
75134   return jresult;
75135 }
75136
75137
75138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
75139   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75140   int arg2 ;
75141
75142   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75143   arg2 = (int)jarg2;
75144   {
75145     try {
75146       (arg1)->SetScrollUpdateDistance(arg2);
75147     } catch (std::out_of_range& e) {
75148       {
75149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75150       };
75151     } catch (std::exception& e) {
75152       {
75153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75154       };
75155     } catch (Dali::DaliException e) {
75156       {
75157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75158       };
75159     } catch (...) {
75160       {
75161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75162       };
75163     }
75164   }
75165
75166 }
75167
75168
75169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
75170   unsigned int jresult ;
75171   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75172   bool result;
75173
75174   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75175   {
75176     try {
75177       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
75178     } catch (std::out_of_range& e) {
75179       {
75180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75181       };
75182     } catch (std::exception& e) {
75183       {
75184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75185       };
75186     } catch (Dali::DaliException e) {
75187       {
75188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75189       };
75190     } catch (...) {
75191       {
75192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75193       };
75194     }
75195   }
75196
75197   jresult = result;
75198   return jresult;
75199 }
75200
75201
75202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
75203   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75204   bool arg2 ;
75205
75206   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75207   arg2 = jarg2 ? true : false;
75208   {
75209     try {
75210       (arg1)->SetAxisAutoLock(arg2);
75211     } catch (std::out_of_range& e) {
75212       {
75213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75214       };
75215     } catch (std::exception& e) {
75216       {
75217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75218       };
75219     } catch (Dali::DaliException e) {
75220       {
75221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75222       };
75223     } catch (...) {
75224       {
75225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75226       };
75227     }
75228   }
75229
75230 }
75231
75232
75233 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
75234   float jresult ;
75235   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75236   float result;
75237
75238   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75239   {
75240     try {
75241       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
75242     } catch (std::out_of_range& e) {
75243       {
75244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75245       };
75246     } catch (std::exception& e) {
75247       {
75248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75249       };
75250     } catch (Dali::DaliException e) {
75251       {
75252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75253       };
75254     } catch (...) {
75255       {
75256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75257       };
75258     }
75259   }
75260
75261   jresult = result;
75262   return jresult;
75263 }
75264
75265
75266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
75267   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75268   float arg2 ;
75269
75270   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75271   arg2 = (float)jarg2;
75272   {
75273     try {
75274       (arg1)->SetAxisAutoLockGradient(arg2);
75275     } catch (std::out_of_range& e) {
75276       {
75277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75278       };
75279     } catch (std::exception& e) {
75280       {
75281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75282       };
75283     } catch (Dali::DaliException e) {
75284       {
75285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75286       };
75287     } catch (...) {
75288       {
75289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75290       };
75291     }
75292   }
75293
75294 }
75295
75296
75297 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
75298   float jresult ;
75299   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75300   float result;
75301
75302   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75303   {
75304     try {
75305       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
75306     } catch (std::out_of_range& e) {
75307       {
75308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75309       };
75310     } catch (std::exception& e) {
75311       {
75312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75313       };
75314     } catch (Dali::DaliException e) {
75315       {
75316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75317       };
75318     } catch (...) {
75319       {
75320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75321       };
75322     }
75323   }
75324
75325   jresult = result;
75326   return jresult;
75327 }
75328
75329
75330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
75331   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75332   float arg2 ;
75333
75334   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75335   arg2 = (float)jarg2;
75336   {
75337     try {
75338       (arg1)->SetFrictionCoefficient(arg2);
75339     } catch (std::out_of_range& e) {
75340       {
75341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75342       };
75343     } catch (std::exception& e) {
75344       {
75345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75346       };
75347     } catch (Dali::DaliException e) {
75348       {
75349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75350       };
75351     } catch (...) {
75352       {
75353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75354       };
75355     }
75356   }
75357
75358 }
75359
75360
75361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
75362   float jresult ;
75363   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75364   float result;
75365
75366   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75367   {
75368     try {
75369       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
75370     } catch (std::out_of_range& e) {
75371       {
75372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75373       };
75374     } catch (std::exception& e) {
75375       {
75376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75377       };
75378     } catch (Dali::DaliException e) {
75379       {
75380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75381       };
75382     } catch (...) {
75383       {
75384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75385       };
75386     }
75387   }
75388
75389   jresult = result;
75390   return jresult;
75391 }
75392
75393
75394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
75395   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75396   float arg2 ;
75397
75398   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75399   arg2 = (float)jarg2;
75400   {
75401     try {
75402       (arg1)->SetFlickSpeedCoefficient(arg2);
75403     } catch (std::out_of_range& e) {
75404       {
75405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75406       };
75407     } catch (std::exception& e) {
75408       {
75409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75410       };
75411     } catch (Dali::DaliException e) {
75412       {
75413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75414       };
75415     } catch (...) {
75416       {
75417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75418       };
75419     }
75420   }
75421
75422 }
75423
75424
75425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
75426   void * jresult ;
75427   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75428   Dali::Vector2 result;
75429
75430   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75431   {
75432     try {
75433       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
75434     } catch (std::out_of_range& e) {
75435       {
75436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75437       };
75438     } catch (std::exception& e) {
75439       {
75440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75441       };
75442     } catch (Dali::DaliException e) {
75443       {
75444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75445       };
75446     } catch (...) {
75447       {
75448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75449       };
75450     }
75451   }
75452
75453   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75454   return jresult;
75455 }
75456
75457
75458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
75459   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75460   Dali::Vector2 *arg2 = 0 ;
75461
75462   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75463   arg2 = (Dali::Vector2 *)jarg2;
75464   if (!arg2) {
75465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75466     return ;
75467   }
75468   {
75469     try {
75470       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
75471     } catch (std::out_of_range& e) {
75472       {
75473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75474       };
75475     } catch (std::exception& e) {
75476       {
75477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75478       };
75479     } catch (Dali::DaliException e) {
75480       {
75481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75482       };
75483     } catch (...) {
75484       {
75485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75486       };
75487     }
75488   }
75489
75490 }
75491
75492
75493 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
75494   float jresult ;
75495   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75496   float result;
75497
75498   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75499   {
75500     try {
75501       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
75502     } catch (std::out_of_range& e) {
75503       {
75504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75505       };
75506     } catch (std::exception& e) {
75507       {
75508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75509       };
75510     } catch (Dali::DaliException e) {
75511       {
75512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75513       };
75514     } catch (...) {
75515       {
75516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75517       };
75518     }
75519   }
75520
75521   jresult = result;
75522   return jresult;
75523 }
75524
75525
75526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
75527   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75528   float arg2 ;
75529
75530   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75531   arg2 = (float)jarg2;
75532   {
75533     try {
75534       (arg1)->SetMinimumSpeedForFlick(arg2);
75535     } catch (std::out_of_range& e) {
75536       {
75537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75538       };
75539     } catch (std::exception& e) {
75540       {
75541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75542       };
75543     } catch (Dali::DaliException e) {
75544       {
75545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75546       };
75547     } catch (...) {
75548       {
75549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75550       };
75551     }
75552   }
75553
75554 }
75555
75556
75557 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
75558   float jresult ;
75559   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75560   float result;
75561
75562   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75563   {
75564     try {
75565       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
75566     } catch (std::out_of_range& e) {
75567       {
75568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75569       };
75570     } catch (std::exception& e) {
75571       {
75572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75573       };
75574     } catch (Dali::DaliException e) {
75575       {
75576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75577       };
75578     } catch (...) {
75579       {
75580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75581       };
75582     }
75583   }
75584
75585   jresult = result;
75586   return jresult;
75587 }
75588
75589
75590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
75591   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75592   float arg2 ;
75593
75594   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75595   arg2 = (float)jarg2;
75596   {
75597     try {
75598       (arg1)->SetMaxFlickSpeed(arg2);
75599     } catch (std::out_of_range& e) {
75600       {
75601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75602       };
75603     } catch (std::exception& e) {
75604       {
75605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75606       };
75607     } catch (Dali::DaliException e) {
75608       {
75609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75610       };
75611     } catch (...) {
75612       {
75613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75614       };
75615     }
75616   }
75617
75618 }
75619
75620
75621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
75622   void * jresult ;
75623   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75624   Dali::Vector2 result;
75625
75626   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75627   {
75628     try {
75629       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
75630     } catch (std::out_of_range& e) {
75631       {
75632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75633       };
75634     } catch (std::exception& e) {
75635       {
75636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75637       };
75638     } catch (Dali::DaliException e) {
75639       {
75640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75641       };
75642     } catch (...) {
75643       {
75644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75645       };
75646     }
75647   }
75648
75649   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75650   return jresult;
75651 }
75652
75653
75654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
75655   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75656   Dali::Vector2 arg2 ;
75657   Dali::Vector2 *argp2 ;
75658
75659   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75660   argp2 = (Dali::Vector2 *)jarg2;
75661   if (!argp2) {
75662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
75663     return ;
75664   }
75665   arg2 = *argp2;
75666   {
75667     try {
75668       (arg1)->SetWheelScrollDistanceStep(arg2);
75669     } catch (std::out_of_range& e) {
75670       {
75671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75672       };
75673     } catch (std::exception& e) {
75674       {
75675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75676       };
75677     } catch (Dali::DaliException e) {
75678       {
75679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75680       };
75681     } catch (...) {
75682       {
75683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75684       };
75685     }
75686   }
75687
75688 }
75689
75690
75691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
75692   void * jresult ;
75693   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75694   Dali::Vector2 result;
75695
75696   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75697   {
75698     try {
75699       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
75700     } catch (std::out_of_range& e) {
75701       {
75702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75703       };
75704     } catch (std::exception& e) {
75705       {
75706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75707       };
75708     } catch (Dali::DaliException e) {
75709       {
75710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75711       };
75712     } catch (...) {
75713       {
75714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75715       };
75716     }
75717   }
75718
75719   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75720   return jresult;
75721 }
75722
75723
75724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
75725   unsigned int jresult ;
75726   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75727   unsigned int result;
75728
75729   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75730   {
75731     try {
75732       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
75733     } catch (std::out_of_range& e) {
75734       {
75735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75736       };
75737     } catch (std::exception& e) {
75738       {
75739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75740       };
75741     } catch (Dali::DaliException e) {
75742       {
75743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75744       };
75745     } catch (...) {
75746       {
75747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75748       };
75749     }
75750   }
75751
75752   jresult = result;
75753   return jresult;
75754 }
75755
75756
75757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
75758   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75759   Dali::Vector2 *arg2 = 0 ;
75760
75761   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75762   arg2 = (Dali::Vector2 *)jarg2;
75763   if (!arg2) {
75764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75765     return ;
75766   }
75767   {
75768     try {
75769       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
75770     } catch (std::out_of_range& e) {
75771       {
75772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75773       };
75774     } catch (std::exception& e) {
75775       {
75776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75777       };
75778     } catch (Dali::DaliException e) {
75779       {
75780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75781       };
75782     } catch (...) {
75783       {
75784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75785       };
75786     }
75787   }
75788
75789 }
75790
75791
75792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
75793   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75794   Dali::Vector2 *arg2 = 0 ;
75795   float arg3 ;
75796
75797   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75798   arg2 = (Dali::Vector2 *)jarg2;
75799   if (!arg2) {
75800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75801     return ;
75802   }
75803   arg3 = (float)jarg3;
75804   {
75805     try {
75806       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
75807     } catch (std::out_of_range& e) {
75808       {
75809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75810       };
75811     } catch (std::exception& e) {
75812       {
75813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75814       };
75815     } catch (Dali::DaliException e) {
75816       {
75817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75818       };
75819     } catch (...) {
75820       {
75821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75822       };
75823     }
75824   }
75825
75826 }
75827
75828
75829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
75830   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75831   Dali::Vector2 *arg2 = 0 ;
75832   float arg3 ;
75833   Dali::AlphaFunction arg4 ;
75834   Dali::AlphaFunction *argp4 ;
75835
75836   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75837   arg2 = (Dali::Vector2 *)jarg2;
75838   if (!arg2) {
75839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75840     return ;
75841   }
75842   arg3 = (float)jarg3;
75843   argp4 = (Dali::AlphaFunction *)jarg4;
75844   if (!argp4) {
75845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75846     return ;
75847   }
75848   arg4 = *argp4;
75849   {
75850     try {
75851       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
75852     } catch (std::out_of_range& e) {
75853       {
75854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75855       };
75856     } catch (std::exception& e) {
75857       {
75858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75859       };
75860     } catch (Dali::DaliException e) {
75861       {
75862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75863       };
75864     } catch (...) {
75865       {
75866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75867       };
75868     }
75869   }
75870
75871 }
75872
75873
75874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
75875   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75876   Dali::Vector2 *arg2 = 0 ;
75877   float arg3 ;
75878   Dali::Toolkit::DirectionBias arg4 ;
75879   Dali::Toolkit::DirectionBias arg5 ;
75880
75881   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75882   arg2 = (Dali::Vector2 *)jarg2;
75883   if (!arg2) {
75884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75885     return ;
75886   }
75887   arg3 = (float)jarg3;
75888   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
75889   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75890   {
75891     try {
75892       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
75893     } catch (std::out_of_range& e) {
75894       {
75895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75896       };
75897     } catch (std::exception& e) {
75898       {
75899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75900       };
75901     } catch (Dali::DaliException e) {
75902       {
75903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75904       };
75905     } catch (...) {
75906       {
75907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75908       };
75909     }
75910   }
75911
75912 }
75913
75914
75915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
75916   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75917   Dali::Vector2 *arg2 = 0 ;
75918   float arg3 ;
75919   Dali::AlphaFunction arg4 ;
75920   Dali::Toolkit::DirectionBias arg5 ;
75921   Dali::Toolkit::DirectionBias arg6 ;
75922   Dali::AlphaFunction *argp4 ;
75923
75924   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75925   arg2 = (Dali::Vector2 *)jarg2;
75926   if (!arg2) {
75927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75928     return ;
75929   }
75930   arg3 = (float)jarg3;
75931   argp4 = (Dali::AlphaFunction *)jarg4;
75932   if (!argp4) {
75933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75934     return ;
75935   }
75936   arg4 = *argp4;
75937   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75938   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
75939   {
75940     try {
75941       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
75942     } catch (std::out_of_range& e) {
75943       {
75944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75945       };
75946     } catch (std::exception& e) {
75947       {
75948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75949       };
75950     } catch (Dali::DaliException e) {
75951       {
75952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75953       };
75954     } catch (...) {
75955       {
75956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75957       };
75958     }
75959   }
75960
75961 }
75962
75963
75964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
75965   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75966   unsigned int arg2 ;
75967
75968   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75969   arg2 = (unsigned int)jarg2;
75970   {
75971     try {
75972       (arg1)->ScrollTo(arg2);
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_6(void * jarg1, unsigned int jarg2, float jarg3) {
75996   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75997   unsigned int arg2 ;
75998   float arg3 ;
75999
76000   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76001   arg2 = (unsigned int)jarg2;
76002   arg3 = (float)jarg3;
76003   {
76004     try {
76005       (arg1)->ScrollTo(arg2,arg3);
76006     } catch (std::out_of_range& e) {
76007       {
76008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76009       };
76010     } catch (std::exception& e) {
76011       {
76012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76013       };
76014     } catch (Dali::DaliException e) {
76015       {
76016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76017       };
76018     } catch (...) {
76019       {
76020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76021       };
76022     }
76023   }
76024
76025 }
76026
76027
76028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
76029   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76030   unsigned int arg2 ;
76031   float arg3 ;
76032   Dali::Toolkit::DirectionBias arg4 ;
76033
76034   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76035   arg2 = (unsigned int)jarg2;
76036   arg3 = (float)jarg3;
76037   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
76038   {
76039     try {
76040       (arg1)->ScrollTo(arg2,arg3,arg4);
76041     } catch (std::out_of_range& e) {
76042       {
76043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76044       };
76045     } catch (std::exception& e) {
76046       {
76047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76048       };
76049     } catch (Dali::DaliException e) {
76050       {
76051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76052       };
76053     } catch (...) {
76054       {
76055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76056       };
76057     }
76058   }
76059
76060 }
76061
76062
76063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
76064   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76065   Dali::Actor *arg2 = 0 ;
76066
76067   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76068   arg2 = (Dali::Actor *)jarg2;
76069   if (!arg2) {
76070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76071     return ;
76072   }
76073   {
76074     try {
76075       (arg1)->ScrollTo(*arg2);
76076     } catch (std::out_of_range& e) {
76077       {
76078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76079       };
76080     } catch (std::exception& e) {
76081       {
76082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76083       };
76084     } catch (Dali::DaliException e) {
76085       {
76086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76087       };
76088     } catch (...) {
76089       {
76090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76091       };
76092     }
76093   }
76094
76095 }
76096
76097
76098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
76099   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76100   Dali::Actor *arg2 = 0 ;
76101   float arg3 ;
76102
76103   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76104   arg2 = (Dali::Actor *)jarg2;
76105   if (!arg2) {
76106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76107     return ;
76108   }
76109   arg3 = (float)jarg3;
76110   {
76111     try {
76112       (arg1)->ScrollTo(*arg2,arg3);
76113     } catch (std::out_of_range& e) {
76114       {
76115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76116       };
76117     } catch (std::exception& e) {
76118       {
76119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76120       };
76121     } catch (Dali::DaliException e) {
76122       {
76123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76124       };
76125     } catch (...) {
76126       {
76127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76128       };
76129     }
76130   }
76131
76132 }
76133
76134
76135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
76136   unsigned int jresult ;
76137   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76138   bool result;
76139
76140   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76141   {
76142     try {
76143       result = (bool)(arg1)->ScrollToSnapPoint();
76144     } catch (std::out_of_range& e) {
76145       {
76146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76147       };
76148     } catch (std::exception& e) {
76149       {
76150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76151       };
76152     } catch (Dali::DaliException e) {
76153       {
76154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76155       };
76156     } catch (...) {
76157       {
76158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76159       };
76160     }
76161   }
76162
76163   jresult = result;
76164   return jresult;
76165 }
76166
76167
76168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
76169   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76170   Dali::Constraint arg2 ;
76171   Dali::Constraint *argp2 ;
76172
76173   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76174   argp2 = (Dali::Constraint *)jarg2;
76175   if (!argp2) {
76176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
76177     return ;
76178   }
76179   arg2 = *argp2;
76180   {
76181     try {
76182       (arg1)->ApplyConstraintToChildren(arg2);
76183     } catch (std::out_of_range& e) {
76184       {
76185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76186       };
76187     } catch (std::exception& e) {
76188       {
76189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76190       };
76191     } catch (Dali::DaliException e) {
76192       {
76193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76194       };
76195     } catch (...) {
76196       {
76197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76198       };
76199     }
76200   }
76201
76202 }
76203
76204
76205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
76206   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76207
76208   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76209   {
76210     try {
76211       (arg1)->RemoveConstraintsFromChildren();
76212     } catch (std::out_of_range& e) {
76213       {
76214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76215       };
76216     } catch (std::exception& e) {
76217       {
76218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76219       };
76220     } catch (Dali::DaliException e) {
76221       {
76222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76223       };
76224     } catch (...) {
76225       {
76226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76227       };
76228     }
76229   }
76230
76231 }
76232
76233
76234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
76235   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76236   Dali::Toolkit::ScrollViewEffect arg2 ;
76237   Dali::Toolkit::ScrollViewEffect *argp2 ;
76238
76239   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76240   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76241   if (!argp2) {
76242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76243     return ;
76244   }
76245   arg2 = *argp2;
76246   {
76247     try {
76248       (arg1)->ApplyEffect(arg2);
76249     } catch (std::out_of_range& e) {
76250       {
76251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76252       };
76253     } catch (std::exception& e) {
76254       {
76255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76256       };
76257     } catch (Dali::DaliException e) {
76258       {
76259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76260       };
76261     } catch (...) {
76262       {
76263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76264       };
76265     }
76266   }
76267
76268 }
76269
76270
76271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
76272   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76273   Dali::Toolkit::ScrollViewEffect arg2 ;
76274   Dali::Toolkit::ScrollViewEffect *argp2 ;
76275
76276   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76277   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76278   if (!argp2) {
76279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76280     return ;
76281   }
76282   arg2 = *argp2;
76283   {
76284     try {
76285       (arg1)->RemoveEffect(arg2);
76286     } catch (std::out_of_range& e) {
76287       {
76288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76289       };
76290     } catch (std::exception& e) {
76291       {
76292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76293       };
76294     } catch (Dali::DaliException e) {
76295       {
76296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76297       };
76298     } catch (...) {
76299       {
76300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76301       };
76302     }
76303   }
76304
76305 }
76306
76307
76308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
76309   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76310
76311   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76312   {
76313     try {
76314       (arg1)->RemoveAllEffects();
76315     } catch (std::out_of_range& e) {
76316       {
76317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76318       };
76319     } catch (std::exception& e) {
76320       {
76321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76322       };
76323     } catch (Dali::DaliException e) {
76324       {
76325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76326       };
76327     } catch (...) {
76328       {
76329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76330       };
76331     }
76332   }
76333
76334 }
76335
76336
76337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
76338   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76339   Dali::Actor arg2 ;
76340   Dali::Actor *argp2 ;
76341
76342   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76343   argp2 = (Dali::Actor *)jarg2;
76344   if (!argp2) {
76345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76346     return ;
76347   }
76348   arg2 = *argp2;
76349   {
76350     try {
76351       (arg1)->BindActor(arg2);
76352     } catch (std::out_of_range& e) {
76353       {
76354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76355       };
76356     } catch (std::exception& e) {
76357       {
76358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76359       };
76360     } catch (Dali::DaliException e) {
76361       {
76362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76363       };
76364     } catch (...) {
76365       {
76366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76367       };
76368     }
76369   }
76370
76371 }
76372
76373
76374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
76375   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76376   Dali::Actor arg2 ;
76377   Dali::Actor *argp2 ;
76378
76379   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76380   argp2 = (Dali::Actor *)jarg2;
76381   if (!argp2) {
76382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76383     return ;
76384   }
76385   arg2 = *argp2;
76386   {
76387     try {
76388       (arg1)->UnbindActor(arg2);
76389     } catch (std::out_of_range& e) {
76390       {
76391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76392       };
76393     } catch (std::exception& e) {
76394       {
76395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76396       };
76397     } catch (Dali::DaliException e) {
76398       {
76399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76400       };
76401     } catch (...) {
76402       {
76403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76404       };
76405     }
76406   }
76407
76408 }
76409
76410
76411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
76412   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76413   Dali::Radian arg2 ;
76414   Dali::Radian arg3 ;
76415   Dali::Radian *argp2 ;
76416   Dali::Radian *argp3 ;
76417
76418   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76419   argp2 = (Dali::Radian *)jarg2;
76420   if (!argp2) {
76421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76422     return ;
76423   }
76424   arg2 = *argp2;
76425   argp3 = (Dali::Radian *)jarg3;
76426   if (!argp3) {
76427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76428     return ;
76429   }
76430   arg3 = *argp3;
76431   {
76432     try {
76433       (arg1)->SetScrollingDirection(arg2,arg3);
76434     } catch (std::out_of_range& e) {
76435       {
76436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76437       };
76438     } catch (std::exception& e) {
76439       {
76440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76441       };
76442     } catch (Dali::DaliException e) {
76443       {
76444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76445       };
76446     } catch (...) {
76447       {
76448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76449       };
76450     }
76451   }
76452
76453 }
76454
76455
76456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
76457   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76458   Dali::Radian arg2 ;
76459   Dali::Radian *argp2 ;
76460
76461   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76462   argp2 = (Dali::Radian *)jarg2;
76463   if (!argp2) {
76464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76465     return ;
76466   }
76467   arg2 = *argp2;
76468   {
76469     try {
76470       (arg1)->SetScrollingDirection(arg2);
76471     } catch (std::out_of_range& e) {
76472       {
76473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76474       };
76475     } catch (std::exception& e) {
76476       {
76477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76478       };
76479     } catch (Dali::DaliException e) {
76480       {
76481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76482       };
76483     } catch (...) {
76484       {
76485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76486       };
76487     }
76488   }
76489
76490 }
76491
76492
76493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
76494   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76495   Dali::Radian arg2 ;
76496   Dali::Radian *argp2 ;
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   {
76506     try {
76507       (arg1)->RemoveScrollingDirection(arg2);
76508     } catch (std::out_of_range& e) {
76509       {
76510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76511       };
76512     } catch (std::exception& e) {
76513       {
76514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76515       };
76516     } catch (Dali::DaliException e) {
76517       {
76518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76519       };
76520     } catch (...) {
76521       {
76522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76523       };
76524     }
76525   }
76526
76527 }
76528
76529
76530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
76531   void * jresult ;
76532   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76533   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
76534
76535   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76536   {
76537     try {
76538       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
76539     } catch (std::out_of_range& e) {
76540       {
76541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76542       };
76543     } catch (std::exception& e) {
76544       {
76545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76546       };
76547     } catch (Dali::DaliException e) {
76548       {
76549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76550       };
76551     } catch (...) {
76552       {
76553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76554       };
76555     }
76556   }
76557
76558   jresult = (void *)result;
76559   return jresult;
76560 }
76561
76562
76563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
76564   int jresult ;
76565   int result;
76566
76567   result = (int)Dali::Toolkit::TableView::Property::ROWS;
76568   jresult = (int)result;
76569   return jresult;
76570 }
76571
76572
76573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
76574   int jresult ;
76575   int result;
76576
76577   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
76578   jresult = (int)result;
76579   return jresult;
76580 }
76581
76582
76583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
76584   int jresult ;
76585   int result;
76586
76587   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
76588   jresult = (int)result;
76589   return jresult;
76590 }
76591
76592
76593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
76594   int jresult ;
76595   int result;
76596
76597   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
76598   jresult = (int)result;
76599   return jresult;
76600 }
76601
76602
76603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
76604   int jresult ;
76605   int result;
76606
76607   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
76608   jresult = (int)result;
76609   return jresult;
76610 }
76611
76612
76613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
76614   void * jresult ;
76615   Dali::Toolkit::TableView::Property *result = 0 ;
76616
76617   {
76618     try {
76619       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
76620     } catch (std::out_of_range& e) {
76621       {
76622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76623       };
76624     } catch (std::exception& e) {
76625       {
76626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76627       };
76628     } catch (Dali::DaliException e) {
76629       {
76630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76631       };
76632     } catch (...) {
76633       {
76634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76635       };
76636     }
76637   }
76638
76639   jresult = (void *)result;
76640   return jresult;
76641 }
76642
76643
76644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
76645   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
76646
76647   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
76648   {
76649     try {
76650       delete arg1;
76651     } catch (std::out_of_range& e) {
76652       {
76653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76654       };
76655     } catch (std::exception& e) {
76656       {
76657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76658       };
76659     } catch (Dali::DaliException e) {
76660       {
76661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76662       };
76663     } catch (...) {
76664       {
76665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76666       };
76667     }
76668   }
76669
76670 }
76671
76672
76673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
76674   int jresult ;
76675   int result;
76676
76677   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
76678   jresult = (int)result;
76679   return jresult;
76680 }
76681
76682
76683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
76684   int jresult ;
76685   int result;
76686
76687   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
76688   jresult = (int)result;
76689   return jresult;
76690 }
76691
76692
76693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
76694   int jresult ;
76695   int result;
76696
76697   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
76698   jresult = (int)result;
76699   return jresult;
76700 }
76701
76702
76703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
76704   int jresult ;
76705   int result;
76706
76707   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
76708   jresult = (int)result;
76709   return jresult;
76710 }
76711
76712
76713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
76714   int jresult ;
76715   int result;
76716
76717   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
76718   jresult = (int)result;
76719   return jresult;
76720 }
76721
76722
76723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
76724   void * jresult ;
76725   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
76726
76727   {
76728     try {
76729       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
76730     } catch (std::out_of_range& e) {
76731       {
76732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76733       };
76734     } catch (std::exception& e) {
76735       {
76736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76737       };
76738     } catch (Dali::DaliException e) {
76739       {
76740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76741       };
76742     } catch (...) {
76743       {
76744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76745       };
76746     }
76747   }
76748
76749   jresult = (void *)result;
76750   return jresult;
76751 }
76752
76753
76754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
76755   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
76756
76757   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
76758   {
76759     try {
76760       delete arg1;
76761     } catch (std::out_of_range& e) {
76762       {
76763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76764       };
76765     } catch (std::exception& e) {
76766       {
76767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76768       };
76769     } catch (Dali::DaliException e) {
76770       {
76771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76772       };
76773     } catch (...) {
76774       {
76775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76776       };
76777     }
76778   }
76779
76780 }
76781
76782
76783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
76784   void * jresult ;
76785   unsigned int arg1 ;
76786   unsigned int arg2 ;
76787   unsigned int arg3 ;
76788   unsigned int arg4 ;
76789   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76790
76791   arg1 = (unsigned int)jarg1;
76792   arg2 = (unsigned int)jarg2;
76793   arg3 = (unsigned int)jarg3;
76794   arg4 = (unsigned int)jarg4;
76795   {
76796     try {
76797       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
76798     } catch (std::out_of_range& e) {
76799       {
76800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76801       };
76802     } catch (std::exception& e) {
76803       {
76804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76805       };
76806     } catch (Dali::DaliException e) {
76807       {
76808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76809       };
76810     } catch (...) {
76811       {
76812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76813       };
76814     }
76815   }
76816
76817   jresult = (void *)result;
76818   return jresult;
76819 }
76820
76821
76822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
76823   void * jresult ;
76824   unsigned int arg1 ;
76825   unsigned int arg2 ;
76826   unsigned int arg3 ;
76827   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76828
76829   arg1 = (unsigned int)jarg1;
76830   arg2 = (unsigned int)jarg2;
76831   arg3 = (unsigned int)jarg3;
76832   {
76833     try {
76834       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
76835     } catch (std::out_of_range& e) {
76836       {
76837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76838       };
76839     } catch (std::exception& e) {
76840       {
76841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76842       };
76843     } catch (Dali::DaliException e) {
76844       {
76845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76846       };
76847     } catch (...) {
76848       {
76849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76850       };
76851     }
76852   }
76853
76854   jresult = (void *)result;
76855   return jresult;
76856 }
76857
76858
76859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
76860   void * jresult ;
76861   unsigned int arg1 ;
76862   unsigned int arg2 ;
76863   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76864
76865   arg1 = (unsigned int)jarg1;
76866   arg2 = (unsigned int)jarg2;
76867   {
76868     try {
76869       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
76870     } catch (std::out_of_range& e) {
76871       {
76872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76873       };
76874     } catch (std::exception& e) {
76875       {
76876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76877       };
76878     } catch (Dali::DaliException e) {
76879       {
76880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76881       };
76882     } catch (...) {
76883       {
76884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76885       };
76886     }
76887   }
76888
76889   jresult = (void *)result;
76890   return jresult;
76891 }
76892
76893
76894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
76895   void * jresult ;
76896   unsigned int arg1 ;
76897   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76898
76899   arg1 = (unsigned int)jarg1;
76900   {
76901     try {
76902       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
76903     } catch (std::out_of_range& e) {
76904       {
76905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76906       };
76907     } catch (std::exception& e) {
76908       {
76909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76910       };
76911     } catch (Dali::DaliException e) {
76912       {
76913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76914       };
76915     } catch (...) {
76916       {
76917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76918       };
76919     }
76920   }
76921
76922   jresult = (void *)result;
76923   return jresult;
76924 }
76925
76926
76927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
76928   void * jresult ;
76929   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76930
76931   {
76932     try {
76933       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
76934     } catch (std::out_of_range& e) {
76935       {
76936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76937       };
76938     } catch (std::exception& e) {
76939       {
76940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76941       };
76942     } catch (Dali::DaliException e) {
76943       {
76944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76945       };
76946     } catch (...) {
76947       {
76948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76949       };
76950     }
76951   }
76952
76953   jresult = (void *)result;
76954   return jresult;
76955 }
76956
76957
76958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
76959   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76960   unsigned int arg2 ;
76961
76962   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76963   arg2 = (unsigned int)jarg2;
76964   if (arg1) (arg1)->rowIndex = arg2;
76965 }
76966
76967
76968 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
76969   unsigned int jresult ;
76970   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76971   unsigned int result;
76972
76973   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76974   result = (unsigned int) ((arg1)->rowIndex);
76975   jresult = result;
76976   return jresult;
76977 }
76978
76979
76980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
76981   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76982   unsigned int arg2 ;
76983
76984   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76985   arg2 = (unsigned int)jarg2;
76986   if (arg1) (arg1)->columnIndex = arg2;
76987 }
76988
76989
76990 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
76991   unsigned int jresult ;
76992   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76993   unsigned int result;
76994
76995   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76996   result = (unsigned int) ((arg1)->columnIndex);
76997   jresult = result;
76998   return jresult;
76999 }
77000
77001
77002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
77003   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77004   unsigned int arg2 ;
77005
77006   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77007   arg2 = (unsigned int)jarg2;
77008   if (arg1) (arg1)->rowSpan = arg2;
77009 }
77010
77011
77012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
77013   unsigned int jresult ;
77014   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77015   unsigned int result;
77016
77017   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77018   result = (unsigned int) ((arg1)->rowSpan);
77019   jresult = result;
77020   return jresult;
77021 }
77022
77023
77024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
77025   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77026   unsigned int arg2 ;
77027
77028   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77029   arg2 = (unsigned int)jarg2;
77030   if (arg1) (arg1)->columnSpan = arg2;
77031 }
77032
77033
77034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
77035   unsigned int jresult ;
77036   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77037   unsigned int result;
77038
77039   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77040   result = (unsigned int) ((arg1)->columnSpan);
77041   jresult = result;
77042   return jresult;
77043 }
77044
77045
77046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
77047   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77048
77049   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77050   {
77051     try {
77052       delete arg1;
77053     } catch (std::out_of_range& e) {
77054       {
77055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77056       };
77057     } catch (std::exception& e) {
77058       {
77059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77060       };
77061     } catch (Dali::DaliException e) {
77062       {
77063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77064       };
77065     } catch (...) {
77066       {
77067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77068       };
77069     }
77070   }
77071
77072 }
77073
77074
77075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
77076   void * jresult ;
77077   Dali::Toolkit::TableView *result = 0 ;
77078
77079   {
77080     try {
77081       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
77082     } catch (std::out_of_range& e) {
77083       {
77084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77085       };
77086     } catch (std::exception& e) {
77087       {
77088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77089       };
77090     } catch (Dali::DaliException e) {
77091       {
77092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77093       };
77094     } catch (...) {
77095       {
77096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77097       };
77098     }
77099   }
77100
77101   jresult = (void *)result;
77102   return jresult;
77103 }
77104
77105
77106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
77107   void * jresult ;
77108   Dali::Toolkit::TableView *arg1 = 0 ;
77109   Dali::Toolkit::TableView *result = 0 ;
77110
77111   arg1 = (Dali::Toolkit::TableView *)jarg1;
77112   if (!arg1) {
77113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77114     return 0;
77115   }
77116   {
77117     try {
77118       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
77119     } catch (std::out_of_range& e) {
77120       {
77121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77122       };
77123     } catch (std::exception& e) {
77124       {
77125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77126       };
77127     } catch (Dali::DaliException e) {
77128       {
77129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77130       };
77131     } catch (...) {
77132       {
77133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77134       };
77135     }
77136   }
77137
77138   jresult = (void *)result;
77139   return jresult;
77140 }
77141
77142
77143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
77144   void * jresult ;
77145   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77146   Dali::Toolkit::TableView *arg2 = 0 ;
77147   Dali::Toolkit::TableView *result = 0 ;
77148
77149   arg1 = (Dali::Toolkit::TableView *)jarg1;
77150   arg2 = (Dali::Toolkit::TableView *)jarg2;
77151   if (!arg2) {
77152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77153     return 0;
77154   }
77155   {
77156     try {
77157       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
77158     } catch (std::out_of_range& e) {
77159       {
77160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77161       };
77162     } catch (std::exception& e) {
77163       {
77164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77165       };
77166     } catch (Dali::DaliException e) {
77167       {
77168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77169       };
77170     } catch (...) {
77171       {
77172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77173       };
77174     }
77175   }
77176
77177   jresult = (void *)result;
77178   return jresult;
77179 }
77180
77181
77182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
77183   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77184
77185   arg1 = (Dali::Toolkit::TableView *)jarg1;
77186   {
77187     try {
77188       delete arg1;
77189     } catch (std::out_of_range& e) {
77190       {
77191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77192       };
77193     } catch (std::exception& e) {
77194       {
77195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77196       };
77197     } catch (Dali::DaliException e) {
77198       {
77199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77200       };
77201     } catch (...) {
77202       {
77203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77204       };
77205     }
77206   }
77207
77208 }
77209
77210
77211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
77212   void * jresult ;
77213   unsigned int arg1 ;
77214   unsigned int arg2 ;
77215   Dali::Toolkit::TableView result;
77216
77217   arg1 = (unsigned int)jarg1;
77218   arg2 = (unsigned int)jarg2;
77219   {
77220     try {
77221       result = Dali::Toolkit::TableView::New(arg1,arg2);
77222     } catch (std::out_of_range& e) {
77223       {
77224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77225       };
77226     } catch (std::exception& e) {
77227       {
77228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77229       };
77230     } catch (Dali::DaliException e) {
77231       {
77232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77233       };
77234     } catch (...) {
77235       {
77236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77237       };
77238     }
77239   }
77240
77241   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77242   return jresult;
77243 }
77244
77245
77246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
77247   void * jresult ;
77248   Dali::BaseHandle arg1 ;
77249   Dali::BaseHandle *argp1 ;
77250   Dali::Toolkit::TableView result;
77251
77252   argp1 = (Dali::BaseHandle *)jarg1;
77253   if (!argp1) {
77254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77255     return 0;
77256   }
77257   arg1 = *argp1;
77258   {
77259     try {
77260       result = Dali::Toolkit::TableView::DownCast(arg1);
77261     } catch (std::out_of_range& e) {
77262       {
77263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77264       };
77265     } catch (std::exception& e) {
77266       {
77267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77268       };
77269     } catch (Dali::DaliException e) {
77270       {
77271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77272       };
77273     } catch (...) {
77274       {
77275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77276       };
77277     }
77278   }
77279
77280   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77281   return jresult;
77282 }
77283
77284
77285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
77286   unsigned int jresult ;
77287   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77288   Dali::Actor arg2 ;
77289   Dali::Toolkit::TableView::CellPosition arg3 ;
77290   Dali::Actor *argp2 ;
77291   Dali::Toolkit::TableView::CellPosition *argp3 ;
77292   bool result;
77293
77294   arg1 = (Dali::Toolkit::TableView *)jarg1;
77295   argp2 = (Dali::Actor *)jarg2;
77296   if (!argp2) {
77297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77298     return 0;
77299   }
77300   arg2 = *argp2;
77301   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77302   if (!argp3) {
77303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77304     return 0;
77305   }
77306   arg3 = *argp3;
77307   {
77308     try {
77309       result = (bool)(arg1)->AddChild(arg2,arg3);
77310     } catch (std::out_of_range& e) {
77311       {
77312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77313       };
77314     } catch (std::exception& e) {
77315       {
77316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77317       };
77318     } catch (Dali::DaliException e) {
77319       {
77320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77321       };
77322     } catch (...) {
77323       {
77324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77325       };
77326     }
77327   }
77328
77329   jresult = result;
77330   return jresult;
77331 }
77332
77333
77334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
77335   void * jresult ;
77336   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77337   Dali::Toolkit::TableView::CellPosition arg2 ;
77338   Dali::Toolkit::TableView::CellPosition *argp2 ;
77339   Dali::Actor result;
77340
77341   arg1 = (Dali::Toolkit::TableView *)jarg1;
77342   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77343   if (!argp2) {
77344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77345     return 0;
77346   }
77347   arg2 = *argp2;
77348   {
77349     try {
77350       result = (arg1)->GetChildAt(arg2);
77351     } catch (std::out_of_range& e) {
77352       {
77353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77354       };
77355     } catch (std::exception& e) {
77356       {
77357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77358       };
77359     } catch (Dali::DaliException e) {
77360       {
77361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77362       };
77363     } catch (...) {
77364       {
77365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77366       };
77367     }
77368   }
77369
77370   jresult = new Dali::Actor((const Dali::Actor &)result);
77371   return jresult;
77372 }
77373
77374
77375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
77376   void * jresult ;
77377   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77378   Dali::Toolkit::TableView::CellPosition arg2 ;
77379   Dali::Toolkit::TableView::CellPosition *argp2 ;
77380   Dali::Actor result;
77381
77382   arg1 = (Dali::Toolkit::TableView *)jarg1;
77383   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77384   if (!argp2) {
77385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77386     return 0;
77387   }
77388   arg2 = *argp2;
77389   {
77390     try {
77391       result = (arg1)->RemoveChildAt(arg2);
77392     } catch (std::out_of_range& e) {
77393       {
77394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77395       };
77396     } catch (std::exception& e) {
77397       {
77398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77399       };
77400     } catch (Dali::DaliException e) {
77401       {
77402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77403       };
77404     } catch (...) {
77405       {
77406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77407       };
77408     }
77409   }
77410
77411   jresult = new Dali::Actor((const Dali::Actor &)result);
77412   return jresult;
77413 }
77414
77415
77416 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
77417   unsigned int jresult ;
77418   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77419   Dali::Actor arg2 ;
77420   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
77421   Dali::Actor *argp2 ;
77422   bool result;
77423
77424   arg1 = (Dali::Toolkit::TableView *)jarg1;
77425   argp2 = (Dali::Actor *)jarg2;
77426   if (!argp2) {
77427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77428     return 0;
77429   }
77430   arg2 = *argp2;
77431   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77432   if (!arg3) {
77433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
77434     return 0;
77435   }
77436   {
77437     try {
77438       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
77439     } catch (std::out_of_range& e) {
77440       {
77441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77442       };
77443     } catch (std::exception& e) {
77444       {
77445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77446       };
77447     } catch (Dali::DaliException e) {
77448       {
77449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77450       };
77451     } catch (...) {
77452       {
77453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77454       };
77455     }
77456   }
77457
77458   jresult = result;
77459   return jresult;
77460 }
77461
77462
77463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
77464   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77465   unsigned int arg2 ;
77466
77467   arg1 = (Dali::Toolkit::TableView *)jarg1;
77468   arg2 = (unsigned int)jarg2;
77469   {
77470     try {
77471       (arg1)->InsertRow(arg2);
77472     } catch (std::out_of_range& e) {
77473       {
77474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77475       };
77476     } catch (std::exception& e) {
77477       {
77478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77479       };
77480     } catch (Dali::DaliException e) {
77481       {
77482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77483       };
77484     } catch (...) {
77485       {
77486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77487       };
77488     }
77489   }
77490
77491 }
77492
77493
77494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
77495   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77496   unsigned int arg2 ;
77497
77498   arg1 = (Dali::Toolkit::TableView *)jarg1;
77499   arg2 = (unsigned int)jarg2;
77500   {
77501     try {
77502       (arg1)->DeleteRow(arg2);
77503     } catch (std::out_of_range& e) {
77504       {
77505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77506       };
77507     } catch (std::exception& e) {
77508       {
77509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77510       };
77511     } catch (Dali::DaliException e) {
77512       {
77513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77514       };
77515     } catch (...) {
77516       {
77517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77518       };
77519     }
77520   }
77521
77522 }
77523
77524
77525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77526   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77527   unsigned int arg2 ;
77528   std::vector< Dali::Actor > *arg3 = 0 ;
77529
77530   arg1 = (Dali::Toolkit::TableView *)jarg1;
77531   arg2 = (unsigned int)jarg2;
77532   arg3 = (std::vector< Dali::Actor > *)jarg3;
77533   if (!arg3) {
77534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77535     return ;
77536   }
77537   {
77538     try {
77539       (arg1)->DeleteRow(arg2,*arg3);
77540     } catch (std::out_of_range& e) {
77541       {
77542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77543       };
77544     } catch (std::exception& e) {
77545       {
77546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77547       };
77548     } catch (Dali::DaliException e) {
77549       {
77550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77551       };
77552     } catch (...) {
77553       {
77554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77555       };
77556     }
77557   }
77558
77559 }
77560
77561
77562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
77563   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77564   unsigned int arg2 ;
77565
77566   arg1 = (Dali::Toolkit::TableView *)jarg1;
77567   arg2 = (unsigned int)jarg2;
77568   {
77569     try {
77570       (arg1)->InsertColumn(arg2);
77571     } catch (std::out_of_range& e) {
77572       {
77573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77574       };
77575     } catch (std::exception& e) {
77576       {
77577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77578       };
77579     } catch (Dali::DaliException e) {
77580       {
77581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77582       };
77583     } catch (...) {
77584       {
77585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77586       };
77587     }
77588   }
77589
77590 }
77591
77592
77593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
77594   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77595   unsigned int arg2 ;
77596
77597   arg1 = (Dali::Toolkit::TableView *)jarg1;
77598   arg2 = (unsigned int)jarg2;
77599   {
77600     try {
77601       (arg1)->DeleteColumn(arg2);
77602     } catch (std::out_of_range& e) {
77603       {
77604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77605       };
77606     } catch (std::exception& e) {
77607       {
77608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77609       };
77610     } catch (Dali::DaliException e) {
77611       {
77612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77613       };
77614     } catch (...) {
77615       {
77616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77617       };
77618     }
77619   }
77620
77621 }
77622
77623
77624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77625   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77626   unsigned int arg2 ;
77627   std::vector< Dali::Actor > *arg3 = 0 ;
77628
77629   arg1 = (Dali::Toolkit::TableView *)jarg1;
77630   arg2 = (unsigned int)jarg2;
77631   arg3 = (std::vector< Dali::Actor > *)jarg3;
77632   if (!arg3) {
77633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77634     return ;
77635   }
77636   {
77637     try {
77638       (arg1)->DeleteColumn(arg2,*arg3);
77639     } catch (std::out_of_range& e) {
77640       {
77641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77642       };
77643     } catch (std::exception& e) {
77644       {
77645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77646       };
77647     } catch (Dali::DaliException e) {
77648       {
77649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77650       };
77651     } catch (...) {
77652       {
77653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77654       };
77655     }
77656   }
77657
77658 }
77659
77660
77661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
77662   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77663   unsigned int arg2 ;
77664   unsigned int arg3 ;
77665
77666   arg1 = (Dali::Toolkit::TableView *)jarg1;
77667   arg2 = (unsigned int)jarg2;
77668   arg3 = (unsigned int)jarg3;
77669   {
77670     try {
77671       (arg1)->Resize(arg2,arg3);
77672     } catch (std::out_of_range& e) {
77673       {
77674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77675       };
77676     } catch (std::exception& e) {
77677       {
77678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77679       };
77680     } catch (Dali::DaliException e) {
77681       {
77682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77683       };
77684     } catch (...) {
77685       {
77686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77687       };
77688     }
77689   }
77690
77691 }
77692
77693
77694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
77695   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77696   unsigned int arg2 ;
77697   unsigned int arg3 ;
77698   std::vector< Dali::Actor > *arg4 = 0 ;
77699
77700   arg1 = (Dali::Toolkit::TableView *)jarg1;
77701   arg2 = (unsigned int)jarg2;
77702   arg3 = (unsigned int)jarg3;
77703   arg4 = (std::vector< Dali::Actor > *)jarg4;
77704   if (!arg4) {
77705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77706     return ;
77707   }
77708   {
77709     try {
77710       (arg1)->Resize(arg2,arg3,*arg4);
77711     } catch (std::out_of_range& e) {
77712       {
77713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77714       };
77715     } catch (std::exception& e) {
77716       {
77717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77718       };
77719     } catch (Dali::DaliException e) {
77720       {
77721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77722       };
77723     } catch (...) {
77724       {
77725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77726       };
77727     }
77728   }
77729
77730 }
77731
77732
77733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
77734   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77735   Dali::Size arg2 ;
77736   Dali::Size *argp2 ;
77737
77738   arg1 = (Dali::Toolkit::TableView *)jarg1;
77739   argp2 = (Dali::Size *)jarg2;
77740   if (!argp2) {
77741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
77742     return ;
77743   }
77744   arg2 = *argp2;
77745   {
77746     try {
77747       (arg1)->SetCellPadding(arg2);
77748     } catch (std::out_of_range& e) {
77749       {
77750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77751       };
77752     } catch (std::exception& e) {
77753       {
77754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77755       };
77756     } catch (Dali::DaliException e) {
77757       {
77758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77759       };
77760     } catch (...) {
77761       {
77762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77763       };
77764     }
77765   }
77766
77767 }
77768
77769
77770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
77771   void * jresult ;
77772   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77773   Dali::Size result;
77774
77775   arg1 = (Dali::Toolkit::TableView *)jarg1;
77776   {
77777     try {
77778       result = (arg1)->GetCellPadding();
77779     } catch (std::out_of_range& e) {
77780       {
77781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77782       };
77783     } catch (std::exception& e) {
77784       {
77785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77786       };
77787     } catch (Dali::DaliException e) {
77788       {
77789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77790       };
77791     } catch (...) {
77792       {
77793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77794       };
77795     }
77796   }
77797
77798   jresult = new Dali::Size((const Dali::Size &)result);
77799   return jresult;
77800 }
77801
77802
77803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
77804   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77805   unsigned int arg2 ;
77806
77807   arg1 = (Dali::Toolkit::TableView *)jarg1;
77808   arg2 = (unsigned int)jarg2;
77809   {
77810     try {
77811       (arg1)->SetFitHeight(arg2);
77812     } catch (std::out_of_range& e) {
77813       {
77814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77815       };
77816     } catch (std::exception& e) {
77817       {
77818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77819       };
77820     } catch (Dali::DaliException e) {
77821       {
77822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77823       };
77824     } catch (...) {
77825       {
77826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77827       };
77828     }
77829   }
77830
77831 }
77832
77833
77834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
77835   unsigned int jresult ;
77836   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77837   unsigned int arg2 ;
77838   bool result;
77839
77840   arg1 = (Dali::Toolkit::TableView *)jarg1;
77841   arg2 = (unsigned int)jarg2;
77842   {
77843     try {
77844       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
77845     } catch (std::out_of_range& e) {
77846       {
77847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77848       };
77849     } catch (std::exception& e) {
77850       {
77851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77852       };
77853     } catch (Dali::DaliException e) {
77854       {
77855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77856       };
77857     } catch (...) {
77858       {
77859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77860       };
77861     }
77862   }
77863
77864   jresult = result;
77865   return jresult;
77866 }
77867
77868
77869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
77870   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77871   unsigned int arg2 ;
77872
77873   arg1 = (Dali::Toolkit::TableView *)jarg1;
77874   arg2 = (unsigned int)jarg2;
77875   {
77876     try {
77877       (arg1)->SetFitWidth(arg2);
77878     } catch (std::out_of_range& e) {
77879       {
77880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77881       };
77882     } catch (std::exception& e) {
77883       {
77884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77885       };
77886     } catch (Dali::DaliException e) {
77887       {
77888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77889       };
77890     } catch (...) {
77891       {
77892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77893       };
77894     }
77895   }
77896
77897 }
77898
77899
77900 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
77901   unsigned int jresult ;
77902   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77903   unsigned int arg2 ;
77904   bool result;
77905
77906   arg1 = (Dali::Toolkit::TableView *)jarg1;
77907   arg2 = (unsigned int)jarg2;
77908   {
77909     try {
77910       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
77911     } catch (std::out_of_range& e) {
77912       {
77913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77914       };
77915     } catch (std::exception& e) {
77916       {
77917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77918       };
77919     } catch (Dali::DaliException e) {
77920       {
77921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77922       };
77923     } catch (...) {
77924       {
77925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77926       };
77927     }
77928   }
77929
77930   jresult = result;
77931   return jresult;
77932 }
77933
77934
77935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
77936   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77937   unsigned int arg2 ;
77938   float arg3 ;
77939
77940   arg1 = (Dali::Toolkit::TableView *)jarg1;
77941   arg2 = (unsigned int)jarg2;
77942   arg3 = (float)jarg3;
77943   {
77944     try {
77945       (arg1)->SetFixedHeight(arg2,arg3);
77946     } catch (std::out_of_range& e) {
77947       {
77948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77949       };
77950     } catch (std::exception& e) {
77951       {
77952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77953       };
77954     } catch (Dali::DaliException e) {
77955       {
77956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77957       };
77958     } catch (...) {
77959       {
77960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77961       };
77962     }
77963   }
77964
77965 }
77966
77967
77968 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
77969   float jresult ;
77970   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77971   unsigned int arg2 ;
77972   float result;
77973
77974   arg1 = (Dali::Toolkit::TableView *)jarg1;
77975   arg2 = (unsigned int)jarg2;
77976   {
77977     try {
77978       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
77979     } catch (std::out_of_range& e) {
77980       {
77981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77982       };
77983     } catch (std::exception& e) {
77984       {
77985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77986       };
77987     } catch (Dali::DaliException e) {
77988       {
77989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77990       };
77991     } catch (...) {
77992       {
77993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77994       };
77995     }
77996   }
77997
77998   jresult = result;
77999   return jresult;
78000 }
78001
78002
78003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
78004   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78005   unsigned int arg2 ;
78006   float arg3 ;
78007
78008   arg1 = (Dali::Toolkit::TableView *)jarg1;
78009   arg2 = (unsigned int)jarg2;
78010   arg3 = (float)jarg3;
78011   {
78012     try {
78013       (arg1)->SetRelativeHeight(arg2,arg3);
78014     } catch (std::out_of_range& e) {
78015       {
78016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78017       };
78018     } catch (std::exception& e) {
78019       {
78020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78021       };
78022     } catch (Dali::DaliException e) {
78023       {
78024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78025       };
78026     } catch (...) {
78027       {
78028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78029       };
78030     }
78031   }
78032
78033 }
78034
78035
78036 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
78037   float jresult ;
78038   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78039   unsigned int arg2 ;
78040   float result;
78041
78042   arg1 = (Dali::Toolkit::TableView *)jarg1;
78043   arg2 = (unsigned int)jarg2;
78044   {
78045     try {
78046       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
78047     } catch (std::out_of_range& e) {
78048       {
78049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78050       };
78051     } catch (std::exception& e) {
78052       {
78053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78054       };
78055     } catch (Dali::DaliException e) {
78056       {
78057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78058       };
78059     } catch (...) {
78060       {
78061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78062       };
78063     }
78064   }
78065
78066   jresult = result;
78067   return jresult;
78068 }
78069
78070
78071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78072   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78073   unsigned int arg2 ;
78074   float arg3 ;
78075
78076   arg1 = (Dali::Toolkit::TableView *)jarg1;
78077   arg2 = (unsigned int)jarg2;
78078   arg3 = (float)jarg3;
78079   {
78080     try {
78081       (arg1)->SetFixedWidth(arg2,arg3);
78082     } catch (std::out_of_range& e) {
78083       {
78084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78085       };
78086     } catch (std::exception& e) {
78087       {
78088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78089       };
78090     } catch (Dali::DaliException e) {
78091       {
78092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78093       };
78094     } catch (...) {
78095       {
78096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78097       };
78098     }
78099   }
78100
78101 }
78102
78103
78104 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
78105   float jresult ;
78106   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78107   unsigned int arg2 ;
78108   float result;
78109
78110   arg1 = (Dali::Toolkit::TableView *)jarg1;
78111   arg2 = (unsigned int)jarg2;
78112   {
78113     try {
78114       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
78115     } catch (std::out_of_range& e) {
78116       {
78117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78118       };
78119     } catch (std::exception& e) {
78120       {
78121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78122       };
78123     } catch (Dali::DaliException e) {
78124       {
78125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78126       };
78127     } catch (...) {
78128       {
78129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78130       };
78131     }
78132   }
78133
78134   jresult = result;
78135   return jresult;
78136 }
78137
78138
78139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78140   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78141   unsigned int arg2 ;
78142   float arg3 ;
78143
78144   arg1 = (Dali::Toolkit::TableView *)jarg1;
78145   arg2 = (unsigned int)jarg2;
78146   arg3 = (float)jarg3;
78147   {
78148     try {
78149       (arg1)->SetRelativeWidth(arg2,arg3);
78150     } catch (std::out_of_range& e) {
78151       {
78152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78153       };
78154     } catch (std::exception& e) {
78155       {
78156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78157       };
78158     } catch (Dali::DaliException e) {
78159       {
78160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78161       };
78162     } catch (...) {
78163       {
78164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78165       };
78166     }
78167   }
78168
78169 }
78170
78171
78172 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
78173   float jresult ;
78174   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78175   unsigned int arg2 ;
78176   float result;
78177
78178   arg1 = (Dali::Toolkit::TableView *)jarg1;
78179   arg2 = (unsigned int)jarg2;
78180   {
78181     try {
78182       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
78183     } catch (std::out_of_range& e) {
78184       {
78185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78186       };
78187     } catch (std::exception& e) {
78188       {
78189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78190       };
78191     } catch (Dali::DaliException e) {
78192       {
78193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78194       };
78195     } catch (...) {
78196       {
78197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78198       };
78199     }
78200   }
78201
78202   jresult = result;
78203   return jresult;
78204 }
78205
78206
78207 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
78208   unsigned int jresult ;
78209   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78210   unsigned int result;
78211
78212   arg1 = (Dali::Toolkit::TableView *)jarg1;
78213   {
78214     try {
78215       result = (unsigned int)(arg1)->GetRows();
78216     } catch (std::out_of_range& e) {
78217       {
78218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78219       };
78220     } catch (std::exception& e) {
78221       {
78222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78223       };
78224     } catch (Dali::DaliException e) {
78225       {
78226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78227       };
78228     } catch (...) {
78229       {
78230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78231       };
78232     }
78233   }
78234
78235   jresult = result;
78236   return jresult;
78237 }
78238
78239
78240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
78241   unsigned int jresult ;
78242   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78243   unsigned int result;
78244
78245   arg1 = (Dali::Toolkit::TableView *)jarg1;
78246   {
78247     try {
78248       result = (unsigned int)(arg1)->GetColumns();
78249     } catch (std::out_of_range& e) {
78250       {
78251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78252       };
78253     } catch (std::exception& e) {
78254       {
78255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78256       };
78257     } catch (Dali::DaliException e) {
78258       {
78259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78260       };
78261     } catch (...) {
78262       {
78263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78264       };
78265     }
78266   }
78267
78268   jresult = result;
78269   return jresult;
78270 }
78271
78272
78273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
78274   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78275   Dali::Toolkit::TableView::CellPosition arg2 ;
78276   Dali::HorizontalAlignment::Type arg3 ;
78277   Dali::VerticalAlignment::Type arg4 ;
78278   Dali::Toolkit::TableView::CellPosition *argp2 ;
78279
78280   arg1 = (Dali::Toolkit::TableView *)jarg1;
78281   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
78282   if (!argp2) {
78283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
78284     return ;
78285   }
78286   arg2 = *argp2;
78287   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
78288   arg4 = (Dali::VerticalAlignment::Type)jarg4;
78289   {
78290     try {
78291       (arg1)->SetCellAlignment(arg2,arg3,arg4);
78292     } catch (std::out_of_range& e) {
78293       {
78294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78295       };
78296     } catch (std::exception& e) {
78297       {
78298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78299       };
78300     } catch (Dali::DaliException e) {
78301       {
78302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78303       };
78304     } catch (...) {
78305       {
78306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78307       };
78308     }
78309   }
78310
78311 }
78312
78313
78314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
78315   unsigned int jresult ;
78316   unsigned int result;
78317
78318   result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
78319   jresult = result;
78320   return jresult;
78321 }
78322
78323
78324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
78325   int jresult ;
78326   int result;
78327
78328   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
78329   jresult = (int)result;
78330   return jresult;
78331 }
78332
78333
78334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
78335   int jresult ;
78336   int result;
78337
78338   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
78339   jresult = (int)result;
78340   return jresult;
78341 }
78342
78343
78344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
78345   int jresult ;
78346   int result;
78347
78348   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
78349   jresult = (int)result;
78350   return jresult;
78351 }
78352
78353
78354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
78355   int jresult ;
78356   int result;
78357
78358   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
78359   jresult = (int)result;
78360   return jresult;
78361 }
78362
78363
78364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
78365   int jresult ;
78366   int result;
78367
78368   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
78369   jresult = (int)result;
78370   return jresult;
78371 }
78372
78373
78374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
78375   int jresult ;
78376   int result;
78377
78378   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
78379   jresult = (int)result;
78380   return jresult;
78381 }
78382
78383
78384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
78385   int jresult ;
78386   int result;
78387
78388   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
78389   jresult = (int)result;
78390   return jresult;
78391 }
78392
78393
78394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
78395   int jresult ;
78396   int result;
78397
78398   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
78399   jresult = (int)result;
78400   return jresult;
78401 }
78402
78403
78404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
78405   int jresult ;
78406   int result;
78407
78408   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
78409   jresult = (int)result;
78410   return jresult;
78411 }
78412
78413
78414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
78415   int jresult ;
78416   int result;
78417
78418   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
78419   jresult = (int)result;
78420   return jresult;
78421 }
78422
78423
78424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
78425   int jresult ;
78426   int result;
78427
78428   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
78429   jresult = (int)result;
78430   return jresult;
78431 }
78432
78433
78434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
78435   int jresult ;
78436   int result;
78437
78438   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
78439   jresult = (int)result;
78440   return jresult;
78441 }
78442
78443
78444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
78445   int jresult ;
78446   int result;
78447
78448   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
78449   jresult = (int)result;
78450   return jresult;
78451 }
78452
78453
78454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
78455   int jresult ;
78456   int result;
78457
78458   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
78459   jresult = (int)result;
78460   return jresult;
78461 }
78462
78463
78464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
78465   int jresult ;
78466   int result;
78467
78468   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
78469   jresult = (int)result;
78470   return jresult;
78471 }
78472
78473
78474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
78475   int jresult ;
78476   int result;
78477
78478   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
78479   jresult = (int)result;
78480   return jresult;
78481 }
78482
78483
78484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
78485   int jresult ;
78486   int result;
78487
78488   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
78489   jresult = (int)result;
78490   return jresult;
78491 }
78492
78493
78494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
78495   int jresult ;
78496   int result;
78497
78498   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
78499   jresult = (int)result;
78500   return jresult;
78501 }
78502
78503
78504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
78505   void * jresult ;
78506   Dali::Toolkit::TextLabel::Property *result = 0 ;
78507
78508   {
78509     try {
78510       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
78511     } catch (std::out_of_range& e) {
78512       {
78513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78514       };
78515     } catch (std::exception& e) {
78516       {
78517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78518       };
78519     } catch (Dali::DaliException e) {
78520       {
78521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78522       };
78523     } catch (...) {
78524       {
78525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78526       };
78527     }
78528   }
78529
78530   jresult = (void *)result;
78531   return jresult;
78532 }
78533
78534
78535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
78536   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
78537
78538   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
78539   {
78540     try {
78541       delete arg1;
78542     } catch (std::out_of_range& e) {
78543       {
78544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78545       };
78546     } catch (std::exception& e) {
78547       {
78548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78549       };
78550     } catch (Dali::DaliException e) {
78551       {
78552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78553       };
78554     } catch (...) {
78555       {
78556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78557       };
78558     }
78559   }
78560
78561 }
78562
78563
78564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
78565   void * jresult ;
78566   Dali::Toolkit::TextLabel result;
78567
78568   {
78569     try {
78570       result = Dali::Toolkit::TextLabel::New();
78571     } catch (std::out_of_range& e) {
78572       {
78573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78574       };
78575     } catch (std::exception& e) {
78576       {
78577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78578       };
78579     } catch (Dali::DaliException e) {
78580       {
78581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78582       };
78583     } catch (...) {
78584       {
78585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78586       };
78587     }
78588   }
78589
78590   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78591   return jresult;
78592 }
78593
78594
78595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
78596   void * jresult ;
78597   std::string *arg1 = 0 ;
78598   Dali::Toolkit::TextLabel result;
78599
78600   if (!jarg1) {
78601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78602     return 0;
78603   }
78604   std::string arg1_str(jarg1);
78605   arg1 = &arg1_str;
78606   {
78607     try {
78608       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
78609     } catch (std::out_of_range& e) {
78610       {
78611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78612       };
78613     } catch (std::exception& e) {
78614       {
78615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78616       };
78617     } catch (Dali::DaliException e) {
78618       {
78619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78620       };
78621     } catch (...) {
78622       {
78623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78624       };
78625     }
78626   }
78627
78628   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78629
78630   //argout typemap for const std::string&
78631
78632   return jresult;
78633 }
78634
78635
78636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
78637   void * jresult ;
78638   Dali::Toolkit::TextLabel *result = 0 ;
78639
78640   {
78641     try {
78642       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
78643     } catch (std::out_of_range& e) {
78644       {
78645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78646       };
78647     } catch (std::exception& e) {
78648       {
78649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78650       };
78651     } catch (Dali::DaliException e) {
78652       {
78653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78654       };
78655     } catch (...) {
78656       {
78657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78658       };
78659     }
78660   }
78661
78662   jresult = (void *)result;
78663   return jresult;
78664 }
78665
78666
78667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
78668   void * jresult ;
78669   Dali::Toolkit::TextLabel *arg1 = 0 ;
78670   Dali::Toolkit::TextLabel *result = 0 ;
78671
78672   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78673   if (!arg1) {
78674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78675     return 0;
78676   }
78677   {
78678     try {
78679       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
78680     } catch (std::out_of_range& e) {
78681       {
78682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78683       };
78684     } catch (std::exception& e) {
78685       {
78686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78687       };
78688     } catch (Dali::DaliException e) {
78689       {
78690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78691       };
78692     } catch (...) {
78693       {
78694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78695       };
78696     }
78697   }
78698
78699   jresult = (void *)result;
78700   return jresult;
78701 }
78702
78703
78704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
78705   void * jresult ;
78706   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78707   Dali::Toolkit::TextLabel *arg2 = 0 ;
78708   Dali::Toolkit::TextLabel *result = 0 ;
78709
78710   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78711   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
78712   if (!arg2) {
78713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78714     return 0;
78715   }
78716   {
78717     try {
78718       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
78719     } catch (std::out_of_range& e) {
78720       {
78721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78722       };
78723     } catch (std::exception& e) {
78724       {
78725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78726       };
78727     } catch (Dali::DaliException e) {
78728       {
78729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78730       };
78731     } catch (...) {
78732       {
78733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78734       };
78735     }
78736   }
78737
78738   jresult = (void *)result;
78739   return jresult;
78740 }
78741
78742
78743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
78744   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78745
78746   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78747   {
78748     try {
78749       delete arg1;
78750     } catch (std::out_of_range& e) {
78751       {
78752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78753       };
78754     } catch (std::exception& e) {
78755       {
78756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78757       };
78758     } catch (Dali::DaliException e) {
78759       {
78760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78761       };
78762     } catch (...) {
78763       {
78764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78765       };
78766     }
78767   }
78768
78769 }
78770
78771
78772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
78773   void * jresult ;
78774   Dali::BaseHandle arg1 ;
78775   Dali::BaseHandle *argp1 ;
78776   Dali::Toolkit::TextLabel result;
78777
78778   argp1 = (Dali::BaseHandle *)jarg1;
78779   if (!argp1) {
78780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78781     return 0;
78782   }
78783   arg1 = *argp1;
78784   {
78785     try {
78786       result = Dali::Toolkit::TextLabel::DownCast(arg1);
78787     } catch (std::out_of_range& e) {
78788       {
78789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78790       };
78791     } catch (std::exception& e) {
78792       {
78793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78794       };
78795     } catch (Dali::DaliException e) {
78796       {
78797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78798       };
78799     } catch (...) {
78800       {
78801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78802       };
78803     }
78804   }
78805
78806   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78807   return jresult;
78808 }
78809
78810
78811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
78812   void * jresult ;
78813   Dali::Toolkit::AccessibilityManager *result = 0 ;
78814
78815   {
78816     try {
78817       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
78818     } catch (std::out_of_range& e) {
78819       {
78820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78821       };
78822     } catch (std::exception& e) {
78823       {
78824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78825       };
78826     } catch (Dali::DaliException e) {
78827       {
78828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78829       };
78830     } catch (...) {
78831       {
78832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78833       };
78834     }
78835   }
78836
78837   jresult = (void *)result;
78838   return jresult;
78839 }
78840
78841
78842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
78843   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78844
78845   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78846   {
78847     try {
78848       delete arg1;
78849     } catch (std::out_of_range& e) {
78850       {
78851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78852       };
78853     } catch (std::exception& e) {
78854       {
78855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78856       };
78857     } catch (Dali::DaliException e) {
78858       {
78859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78860       };
78861     } catch (...) {
78862       {
78863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78864       };
78865     }
78866   }
78867
78868 }
78869
78870
78871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
78872   void * jresult ;
78873   Dali::Toolkit::AccessibilityManager result;
78874
78875   {
78876     try {
78877       result = Dali::Toolkit::AccessibilityManager::Get();
78878     } catch (std::out_of_range& e) {
78879       {
78880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78881       };
78882     } catch (std::exception& e) {
78883       {
78884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78885       };
78886     } catch (Dali::DaliException e) {
78887       {
78888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78889       };
78890     } catch (...) {
78891       {
78892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78893       };
78894     }
78895   }
78896
78897   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
78898   return jresult;
78899 }
78900
78901
78902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
78903   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78904   Dali::Actor arg2 ;
78905   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78906   std::string *arg4 = 0 ;
78907   Dali::Actor *argp2 ;
78908
78909   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78910   argp2 = (Dali::Actor *)jarg2;
78911   if (!argp2) {
78912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78913     return ;
78914   }
78915   arg2 = *argp2;
78916   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78917   if (!jarg4) {
78918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78919     return ;
78920   }
78921   std::string arg4_str(jarg4);
78922   arg4 = &arg4_str;
78923   {
78924     try {
78925       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
78926     } catch (std::out_of_range& e) {
78927       {
78928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78929       };
78930     } catch (std::exception& e) {
78931       {
78932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78933       };
78934     } catch (Dali::DaliException e) {
78935       {
78936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78937       };
78938     } catch (...) {
78939       {
78940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78941       };
78942     }
78943   }
78944
78945
78946   //argout typemap for const std::string&
78947
78948 }
78949
78950
78951 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
78952   char * jresult ;
78953   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78954   Dali::Actor arg2 ;
78955   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78956   Dali::Actor *argp2 ;
78957   std::string result;
78958
78959   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78960   argp2 = (Dali::Actor *)jarg2;
78961   if (!argp2) {
78962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78963     return 0;
78964   }
78965   arg2 = *argp2;
78966   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78967   {
78968     try {
78969       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
78970     } catch (std::out_of_range& e) {
78971       {
78972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78973       };
78974     } catch (std::exception& e) {
78975       {
78976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78977       };
78978     } catch (Dali::DaliException e) {
78979       {
78980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78981       };
78982     } catch (...) {
78983       {
78984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78985       };
78986     }
78987   }
78988
78989   jresult = SWIG_csharp_string_callback((&result)->c_str());
78990   return jresult;
78991 }
78992
78993
78994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
78995   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78996   Dali::Actor arg2 ;
78997   unsigned int arg3 ;
78998   Dali::Actor *argp2 ;
78999
79000   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79001   argp2 = (Dali::Actor *)jarg2;
79002   if (!argp2) {
79003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79004     return ;
79005   }
79006   arg2 = *argp2;
79007   arg3 = (unsigned int)jarg3;
79008   {
79009     try {
79010       (arg1)->SetFocusOrder(arg2,arg3);
79011     } catch (std::out_of_range& e) {
79012       {
79013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79014       };
79015     } catch (std::exception& e) {
79016       {
79017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79018       };
79019     } catch (Dali::DaliException e) {
79020       {
79021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79022       };
79023     } catch (...) {
79024       {
79025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79026       };
79027     }
79028   }
79029
79030 }
79031
79032
79033 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
79034   unsigned int jresult ;
79035   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79036   Dali::Actor arg2 ;
79037   Dali::Actor *argp2 ;
79038   unsigned int result;
79039
79040   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79041   argp2 = (Dali::Actor *)jarg2;
79042   if (!argp2) {
79043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79044     return 0;
79045   }
79046   arg2 = *argp2;
79047   {
79048     try {
79049       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
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 = result;
79070   return jresult;
79071 }
79072
79073
79074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
79075   unsigned int jresult ;
79076   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79077   unsigned int result;
79078
79079   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79080   {
79081     try {
79082       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
79083     } catch (std::out_of_range& e) {
79084       {
79085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79086       };
79087     } catch (std::exception& e) {
79088       {
79089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79090       };
79091     } catch (Dali::DaliException e) {
79092       {
79093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79094       };
79095     } catch (...) {
79096       {
79097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79098       };
79099     }
79100   }
79101
79102   jresult = result;
79103   return jresult;
79104 }
79105
79106
79107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
79108   void * jresult ;
79109   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79110   unsigned int arg2 ;
79111   Dali::Actor result;
79112
79113   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79114   arg2 = (unsigned int)jarg2;
79115   {
79116     try {
79117       result = (arg1)->GetActorByFocusOrder(arg2);
79118     } catch (std::out_of_range& e) {
79119       {
79120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79121       };
79122     } catch (std::exception& e) {
79123       {
79124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79125       };
79126     } catch (Dali::DaliException e) {
79127       {
79128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79129       };
79130     } catch (...) {
79131       {
79132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79133       };
79134     }
79135   }
79136
79137   jresult = new Dali::Actor((const Dali::Actor &)result);
79138   return jresult;
79139 }
79140
79141
79142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
79143   unsigned int jresult ;
79144   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79145   Dali::Actor arg2 ;
79146   Dali::Actor *argp2 ;
79147   bool result;
79148
79149   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79150   argp2 = (Dali::Actor *)jarg2;
79151   if (!argp2) {
79152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79153     return 0;
79154   }
79155   arg2 = *argp2;
79156   {
79157     try {
79158       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
79159     } catch (std::out_of_range& e) {
79160       {
79161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79162       };
79163     } catch (std::exception& e) {
79164       {
79165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79166       };
79167     } catch (Dali::DaliException e) {
79168       {
79169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79170       };
79171     } catch (...) {
79172       {
79173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79174       };
79175     }
79176   }
79177
79178   jresult = result;
79179   return jresult;
79180 }
79181
79182
79183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
79184   void * jresult ;
79185   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79186   Dali::Actor result;
79187
79188   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79189   {
79190     try {
79191       result = (arg1)->GetCurrentFocusActor();
79192     } catch (std::out_of_range& e) {
79193       {
79194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79195       };
79196     } catch (std::exception& e) {
79197       {
79198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79199       };
79200     } catch (Dali::DaliException e) {
79201       {
79202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79203       };
79204     } catch (...) {
79205       {
79206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79207       };
79208     }
79209   }
79210
79211   jresult = new Dali::Actor((const Dali::Actor &)result);
79212   return jresult;
79213 }
79214
79215
79216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
79217   void * jresult ;
79218   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79219   Dali::Actor result;
79220
79221   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79222   {
79223     try {
79224       result = (arg1)->GetCurrentFocusGroup();
79225     } catch (std::out_of_range& e) {
79226       {
79227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79228       };
79229     } catch (std::exception& e) {
79230       {
79231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79232       };
79233     } catch (Dali::DaliException e) {
79234       {
79235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79236       };
79237     } catch (...) {
79238       {
79239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79240       };
79241     }
79242   }
79243
79244   jresult = new Dali::Actor((const Dali::Actor &)result);
79245   return jresult;
79246 }
79247
79248
79249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
79250   unsigned int jresult ;
79251   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79252   unsigned int result;
79253
79254   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79255   {
79256     try {
79257       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
79258     } catch (std::out_of_range& e) {
79259       {
79260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79261       };
79262     } catch (std::exception& e) {
79263       {
79264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79265       };
79266     } catch (Dali::DaliException e) {
79267       {
79268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79269       };
79270     } catch (...) {
79271       {
79272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79273       };
79274     }
79275   }
79276
79277   jresult = result;
79278   return jresult;
79279 }
79280
79281
79282 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
79283   unsigned int jresult ;
79284   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79285   bool result;
79286
79287   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79288   {
79289     try {
79290       result = (bool)(arg1)->MoveFocusForward();
79291     } catch (std::out_of_range& e) {
79292       {
79293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79294       };
79295     } catch (std::exception& e) {
79296       {
79297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79298       };
79299     } catch (Dali::DaliException e) {
79300       {
79301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79302       };
79303     } catch (...) {
79304       {
79305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79306       };
79307     }
79308   }
79309
79310   jresult = result;
79311   return jresult;
79312 }
79313
79314
79315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
79316   unsigned int jresult ;
79317   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79318   bool result;
79319
79320   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79321   {
79322     try {
79323       result = (bool)(arg1)->MoveFocusBackward();
79324     } catch (std::out_of_range& e) {
79325       {
79326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79327       };
79328     } catch (std::exception& e) {
79329       {
79330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79331       };
79332     } catch (Dali::DaliException e) {
79333       {
79334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79335       };
79336     } catch (...) {
79337       {
79338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79339       };
79340     }
79341   }
79342
79343   jresult = result;
79344   return jresult;
79345 }
79346
79347
79348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
79349   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79350
79351   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79352   {
79353     try {
79354       (arg1)->ClearFocus();
79355     } catch (std::out_of_range& e) {
79356       {
79357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79358       };
79359     } catch (std::exception& e) {
79360       {
79361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79362       };
79363     } catch (Dali::DaliException e) {
79364       {
79365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79366       };
79367     } catch (...) {
79368       {
79369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79370       };
79371     }
79372   }
79373
79374 }
79375
79376
79377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
79378   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79379
79380   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79381   {
79382     try {
79383       (arg1)->Reset();
79384     } catch (std::out_of_range& e) {
79385       {
79386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79387       };
79388     } catch (std::exception& e) {
79389       {
79390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79391       };
79392     } catch (Dali::DaliException e) {
79393       {
79394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79395       };
79396     } catch (...) {
79397       {
79398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79399       };
79400     }
79401   }
79402
79403 }
79404
79405
79406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
79407   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79408   Dali::Actor arg2 ;
79409   bool arg3 ;
79410   Dali::Actor *argp2 ;
79411
79412   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79413   argp2 = (Dali::Actor *)jarg2;
79414   if (!argp2) {
79415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79416     return ;
79417   }
79418   arg2 = *argp2;
79419   arg3 = jarg3 ? true : false;
79420   {
79421     try {
79422       (arg1)->SetFocusGroup(arg2,arg3);
79423     } catch (std::out_of_range& e) {
79424       {
79425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79426       };
79427     } catch (std::exception& e) {
79428       {
79429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79430       };
79431     } catch (Dali::DaliException e) {
79432       {
79433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79434       };
79435     } catch (...) {
79436       {
79437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79438       };
79439     }
79440   }
79441
79442 }
79443
79444
79445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
79446   unsigned int jresult ;
79447   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79448   Dali::Actor arg2 ;
79449   Dali::Actor *argp2 ;
79450   bool result;
79451
79452   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79453   argp2 = (Dali::Actor *)jarg2;
79454   if (!argp2) {
79455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79456     return 0;
79457   }
79458   arg2 = *argp2;
79459   {
79460     try {
79461       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
79462     } catch (std::out_of_range& e) {
79463       {
79464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79465       };
79466     } catch (std::exception& e) {
79467       {
79468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79469       };
79470     } catch (Dali::DaliException e) {
79471       {
79472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79473       };
79474     } catch (...) {
79475       {
79476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79477       };
79478     }
79479   }
79480
79481   jresult = result;
79482   return jresult;
79483 }
79484
79485
79486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
79487   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79488   bool arg2 ;
79489
79490   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79491   arg2 = jarg2 ? true : false;
79492   {
79493     try {
79494       (arg1)->SetGroupMode(arg2);
79495     } catch (std::out_of_range& e) {
79496       {
79497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79498       };
79499     } catch (std::exception& e) {
79500       {
79501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79502       };
79503     } catch (Dali::DaliException e) {
79504       {
79505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79506       };
79507     } catch (...) {
79508       {
79509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79510       };
79511     }
79512   }
79513
79514 }
79515
79516
79517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
79518   unsigned int jresult ;
79519   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79520   bool result;
79521
79522   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79523   {
79524     try {
79525       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
79526     } catch (std::out_of_range& e) {
79527       {
79528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79529       };
79530     } catch (std::exception& e) {
79531       {
79532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79533       };
79534     } catch (Dali::DaliException e) {
79535       {
79536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79537       };
79538     } catch (...) {
79539       {
79540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79541       };
79542     }
79543   }
79544
79545   jresult = result;
79546   return jresult;
79547 }
79548
79549
79550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
79551   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79552   bool arg2 ;
79553
79554   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79555   arg2 = jarg2 ? true : false;
79556   {
79557     try {
79558       (arg1)->SetWrapMode(arg2);
79559     } catch (std::out_of_range& e) {
79560       {
79561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79562       };
79563     } catch (std::exception& e) {
79564       {
79565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79566       };
79567     } catch (Dali::DaliException e) {
79568       {
79569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79570       };
79571     } catch (...) {
79572       {
79573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79574       };
79575     }
79576   }
79577
79578 }
79579
79580
79581 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
79582   unsigned int jresult ;
79583   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79584   bool result;
79585
79586   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79587   {
79588     try {
79589       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
79590     } catch (std::out_of_range& e) {
79591       {
79592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79593       };
79594     } catch (std::exception& e) {
79595       {
79596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79597       };
79598     } catch (Dali::DaliException e) {
79599       {
79600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79601       };
79602     } catch (...) {
79603       {
79604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79605       };
79606     }
79607   }
79608
79609   jresult = result;
79610   return jresult;
79611 }
79612
79613
79614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
79615   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79616   Dali::Actor arg2 ;
79617   Dali::Actor *argp2 ;
79618
79619   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79620   argp2 = (Dali::Actor *)jarg2;
79621   if (!argp2) {
79622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79623     return ;
79624   }
79625   arg2 = *argp2;
79626   {
79627     try {
79628       (arg1)->SetFocusIndicatorActor(arg2);
79629     } catch (std::out_of_range& e) {
79630       {
79631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79632       };
79633     } catch (std::exception& e) {
79634       {
79635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79636       };
79637     } catch (Dali::DaliException e) {
79638       {
79639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79640       };
79641     } catch (...) {
79642       {
79643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79644       };
79645     }
79646   }
79647
79648 }
79649
79650
79651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
79652   void * jresult ;
79653   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79654   Dali::Actor result;
79655
79656   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79657   {
79658     try {
79659       result = (arg1)->GetFocusIndicatorActor();
79660     } catch (std::out_of_range& e) {
79661       {
79662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79663       };
79664     } catch (std::exception& e) {
79665       {
79666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79667       };
79668     } catch (Dali::DaliException e) {
79669       {
79670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79671       };
79672     } catch (...) {
79673       {
79674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79675       };
79676     }
79677   }
79678
79679   jresult = new Dali::Actor((const Dali::Actor &)result);
79680   return jresult;
79681 }
79682
79683
79684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
79685   void * jresult ;
79686   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79687   Dali::Actor arg2 ;
79688   Dali::Actor *argp2 ;
79689   Dali::Actor result;
79690
79691   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79692   argp2 = (Dali::Actor *)jarg2;
79693   if (!argp2) {
79694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79695     return 0;
79696   }
79697   arg2 = *argp2;
79698   {
79699     try {
79700       result = (arg1)->GetFocusGroup(arg2);
79701     } catch (std::out_of_range& e) {
79702       {
79703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79704       };
79705     } catch (std::exception& e) {
79706       {
79707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79708       };
79709     } catch (Dali::DaliException e) {
79710       {
79711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79712       };
79713     } catch (...) {
79714       {
79715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79716       };
79717     }
79718   }
79719
79720   jresult = new Dali::Actor((const Dali::Actor &)result);
79721   return jresult;
79722 }
79723
79724
79725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
79726   void * jresult ;
79727   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79728   Dali::Vector2 result;
79729
79730   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79731   {
79732     try {
79733       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
79734     } catch (std::out_of_range& e) {
79735       {
79736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79737       };
79738     } catch (std::exception& e) {
79739       {
79740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79741       };
79742     } catch (Dali::DaliException e) {
79743       {
79744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79745       };
79746     } catch (...) {
79747       {
79748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79749       };
79750     }
79751   }
79752
79753   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79754   return jresult;
79755 }
79756
79757
79758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
79759   void * jresult ;
79760   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79761   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
79762
79763   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79764   {
79765     try {
79766       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
79767     } catch (std::out_of_range& e) {
79768       {
79769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79770       };
79771     } catch (std::exception& e) {
79772       {
79773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79774       };
79775     } catch (Dali::DaliException e) {
79776       {
79777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79778       };
79779     } catch (...) {
79780       {
79781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79782       };
79783     }
79784   }
79785
79786   jresult = (void *)result;
79787   return jresult;
79788 }
79789
79790
79791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
79792   void * jresult ;
79793   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79794   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
79795
79796   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79797   {
79798     try {
79799       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
79800     } catch (std::out_of_range& e) {
79801       {
79802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79803       };
79804     } catch (std::exception& e) {
79805       {
79806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79807       };
79808     } catch (Dali::DaliException e) {
79809       {
79810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79811       };
79812     } catch (...) {
79813       {
79814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79815       };
79816     }
79817   }
79818
79819   jresult = (void *)result;
79820   return jresult;
79821 }
79822
79823
79824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
79825   void * jresult ;
79826   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79827   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
79828
79829   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79830   {
79831     try {
79832       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
79833     } catch (std::out_of_range& e) {
79834       {
79835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79836       };
79837     } catch (std::exception& e) {
79838       {
79839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79840       };
79841     } catch (Dali::DaliException e) {
79842       {
79843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79844       };
79845     } catch (...) {
79846       {
79847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79848       };
79849     }
79850   }
79851
79852   jresult = (void *)result;
79853   return jresult;
79854 }
79855
79856
79857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
79858   void * jresult ;
79859   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79860   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79861
79862   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79863   {
79864     try {
79865       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
79866     } catch (std::out_of_range& e) {
79867       {
79868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79869       };
79870     } catch (std::exception& e) {
79871       {
79872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79873       };
79874     } catch (Dali::DaliException e) {
79875       {
79876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79877       };
79878     } catch (...) {
79879       {
79880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79881       };
79882     }
79883   }
79884
79885   jresult = (void *)result;
79886   return jresult;
79887 }
79888
79889
79890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
79891   void * jresult ;
79892   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79893   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79894
79895   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79896   {
79897     try {
79898       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
79899     } catch (std::out_of_range& e) {
79900       {
79901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79902       };
79903     } catch (std::exception& e) {
79904       {
79905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79906       };
79907     } catch (Dali::DaliException e) {
79908       {
79909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79910       };
79911     } catch (...) {
79912       {
79913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79914       };
79915     }
79916   }
79917
79918   jresult = (void *)result;
79919   return jresult;
79920 }
79921
79922
79923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
79924   void * jresult ;
79925   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79926   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79927
79928   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79929   {
79930     try {
79931       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
79932     } catch (std::out_of_range& e) {
79933       {
79934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79935       };
79936     } catch (std::exception& e) {
79937       {
79938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79939       };
79940     } catch (Dali::DaliException e) {
79941       {
79942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79943       };
79944     } catch (...) {
79945       {
79946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79947       };
79948     }
79949   }
79950
79951   jresult = (void *)result;
79952   return jresult;
79953 }
79954
79955
79956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
79957   void * jresult ;
79958   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79959   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79960
79961   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79962   {
79963     try {
79964       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
79965     } catch (std::out_of_range& e) {
79966       {
79967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79968       };
79969     } catch (std::exception& e) {
79970       {
79971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79972       };
79973     } catch (Dali::DaliException e) {
79974       {
79975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79976       };
79977     } catch (...) {
79978       {
79979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79980       };
79981     }
79982   }
79983
79984   jresult = (void *)result;
79985   return jresult;
79986 }
79987
79988
79989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
79990   void * jresult ;
79991   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79992   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79993
79994   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79995   {
79996     try {
79997       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
79998     } catch (std::out_of_range& e) {
79999       {
80000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80001       };
80002     } catch (std::exception& e) {
80003       {
80004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80005       };
80006     } catch (Dali::DaliException e) {
80007       {
80008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80009       };
80010     } catch (...) {
80011       {
80012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80013       };
80014     }
80015   }
80016
80017   jresult = (void *)result;
80018   return jresult;
80019 }
80020
80021
80022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
80023   void * jresult ;
80024   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80025   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80026
80027   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80028   {
80029     try {
80030       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
80031     } catch (std::out_of_range& e) {
80032       {
80033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80034       };
80035     } catch (std::exception& e) {
80036       {
80037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80038       };
80039     } catch (Dali::DaliException e) {
80040       {
80041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80042       };
80043     } catch (...) {
80044       {
80045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80046       };
80047     }
80048   }
80049
80050   jresult = (void *)result;
80051   return jresult;
80052 }
80053
80054
80055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
80056   void * jresult ;
80057   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80058   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80059
80060   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80061   {
80062     try {
80063       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
80064     } catch (std::out_of_range& e) {
80065       {
80066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80067       };
80068     } catch (std::exception& e) {
80069       {
80070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80071       };
80072     } catch (Dali::DaliException e) {
80073       {
80074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80075       };
80076     } catch (...) {
80077       {
80078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80079       };
80080     }
80081   }
80082
80083   jresult = (void *)result;
80084   return jresult;
80085 }
80086
80087
80088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
80089   void * jresult ;
80090   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80091   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80092
80093   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80094   {
80095     try {
80096       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
80097     } catch (std::out_of_range& e) {
80098       {
80099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80100       };
80101     } catch (std::exception& e) {
80102       {
80103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80104       };
80105     } catch (Dali::DaliException e) {
80106       {
80107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80108       };
80109     } catch (...) {
80110       {
80111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80112       };
80113     }
80114   }
80115
80116   jresult = (void *)result;
80117   return jresult;
80118 }
80119
80120
80121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
80122   void * jresult ;
80123   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80124   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80125
80126   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80127   {
80128     try {
80129       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
80130     } catch (std::out_of_range& e) {
80131       {
80132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80133       };
80134     } catch (std::exception& e) {
80135       {
80136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80137       };
80138     } catch (Dali::DaliException e) {
80139       {
80140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80141       };
80142     } catch (...) {
80143       {
80144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80145       };
80146     }
80147   }
80148
80149   jresult = (void *)result;
80150   return jresult;
80151 }
80152
80153
80154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
80155   void * jresult ;
80156   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80157   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80158
80159   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80160   {
80161     try {
80162       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
80163     } catch (std::out_of_range& e) {
80164       {
80165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80166       };
80167     } catch (std::exception& e) {
80168       {
80169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80170       };
80171     } catch (Dali::DaliException e) {
80172       {
80173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80174       };
80175     } catch (...) {
80176       {
80177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80178       };
80179     }
80180   }
80181
80182   jresult = (void *)result;
80183   return jresult;
80184 }
80185
80186
80187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
80188   void * jresult ;
80189   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80190   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80191
80192   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80193   {
80194     try {
80195       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
80196     } catch (std::out_of_range& e) {
80197       {
80198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80199       };
80200     } catch (std::exception& e) {
80201       {
80202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80203       };
80204     } catch (Dali::DaliException e) {
80205       {
80206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80207       };
80208     } catch (...) {
80209       {
80210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80211       };
80212     }
80213   }
80214
80215   jresult = (void *)result;
80216   return jresult;
80217 }
80218
80219
80220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
80221   void * jresult ;
80222   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80223   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80224
80225   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80226   {
80227     try {
80228       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
80229     } catch (std::out_of_range& e) {
80230       {
80231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80232       };
80233     } catch (std::exception& e) {
80234       {
80235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80236       };
80237     } catch (Dali::DaliException e) {
80238       {
80239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80240       };
80241     } catch (...) {
80242       {
80243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80244       };
80245     }
80246   }
80247
80248   jresult = (void *)result;
80249   return jresult;
80250 }
80251
80252
80253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
80254   void * jresult ;
80255   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80256   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80257
80258   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80259   {
80260     try {
80261       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
80262     } catch (std::out_of_range& e) {
80263       {
80264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80265       };
80266     } catch (std::exception& e) {
80267       {
80268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80269       };
80270     } catch (Dali::DaliException e) {
80271       {
80272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80273       };
80274     } catch (...) {
80275       {
80276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80277       };
80278     }
80279   }
80280
80281   jresult = (void *)result;
80282   return jresult;
80283 }
80284
80285
80286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
80287   void * jresult ;
80288   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80289   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80290
80291   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80292   {
80293     try {
80294       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
80295     } catch (std::out_of_range& e) {
80296       {
80297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80298       };
80299     } catch (std::exception& e) {
80300       {
80301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80302       };
80303     } catch (Dali::DaliException e) {
80304       {
80305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80306       };
80307     } catch (...) {
80308       {
80309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80310       };
80311     }
80312   }
80313
80314   jresult = (void *)result;
80315   return jresult;
80316 }
80317
80318
80319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
80320   void * jresult ;
80321   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80322   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80323
80324   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80325   {
80326     try {
80327       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
80328     } catch (std::out_of_range& e) {
80329       {
80330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80331       };
80332     } catch (std::exception& e) {
80333       {
80334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80335       };
80336     } catch (Dali::DaliException e) {
80337       {
80338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80339       };
80340     } catch (...) {
80341       {
80342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80343       };
80344     }
80345   }
80346
80347   jresult = (void *)result;
80348   return jresult;
80349 }
80350
80351
80352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
80353   void * jresult ;
80354   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80355   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80356
80357   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80358   {
80359     try {
80360       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
80361     } catch (std::out_of_range& e) {
80362       {
80363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80364       };
80365     } catch (std::exception& e) {
80366       {
80367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80368       };
80369     } catch (Dali::DaliException e) {
80370       {
80371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80372       };
80373     } catch (...) {
80374       {
80375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80376       };
80377     }
80378   }
80379
80380   jresult = (void *)result;
80381   return jresult;
80382 }
80383
80384
80385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
80386   void * jresult ;
80387   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80388   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80389
80390   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80391   {
80392     try {
80393       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
80394     } catch (std::out_of_range& e) {
80395       {
80396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80397       };
80398     } catch (std::exception& e) {
80399       {
80400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80401       };
80402     } catch (Dali::DaliException e) {
80403       {
80404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80405       };
80406     } catch (...) {
80407       {
80408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80409       };
80410     }
80411   }
80412
80413   jresult = (void *)result;
80414   return jresult;
80415 }
80416
80417
80418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
80419   void * jresult ;
80420   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80421   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80422
80423   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80424   {
80425     try {
80426       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
80427     } catch (std::out_of_range& e) {
80428       {
80429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80430       };
80431     } catch (std::exception& e) {
80432       {
80433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80434       };
80435     } catch (Dali::DaliException e) {
80436       {
80437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80438       };
80439     } catch (...) {
80440       {
80441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80442       };
80443     }
80444   }
80445
80446   jresult = (void *)result;
80447   return jresult;
80448 }
80449
80450
80451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
80452   void * jresult ;
80453   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80454   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80455
80456   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80457   {
80458     try {
80459       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
80460     } catch (std::out_of_range& e) {
80461       {
80462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80463       };
80464     } catch (std::exception& e) {
80465       {
80466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80467       };
80468     } catch (Dali::DaliException e) {
80469       {
80470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80471       };
80472     } catch (...) {
80473       {
80474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80475       };
80476     }
80477   }
80478
80479   jresult = (void *)result;
80480   return jresult;
80481 }
80482
80483
80484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
80485   void * jresult ;
80486   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80487   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80488
80489   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80490   {
80491     try {
80492       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
80493     } catch (std::out_of_range& e) {
80494       {
80495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80496       };
80497     } catch (std::exception& e) {
80498       {
80499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80500       };
80501     } catch (Dali::DaliException e) {
80502       {
80503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80504       };
80505     } catch (...) {
80506       {
80507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80508       };
80509     }
80510   }
80511
80512   jresult = (void *)result;
80513   return jresult;
80514 }
80515
80516
80517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
80518   void * jresult ;
80519   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80520   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80521
80522   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80523   {
80524     try {
80525       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
80526     } catch (std::out_of_range& e) {
80527       {
80528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80529       };
80530     } catch (std::exception& e) {
80531       {
80532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80533       };
80534     } catch (Dali::DaliException e) {
80535       {
80536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80537       };
80538     } catch (...) {
80539       {
80540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80541       };
80542     }
80543   }
80544
80545   jresult = (void *)result;
80546   return jresult;
80547 }
80548
80549
80550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
80551   void * jresult ;
80552   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80553   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80554
80555   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80556   {
80557     try {
80558       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
80559     } catch (std::out_of_range& e) {
80560       {
80561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80562       };
80563     } catch (std::exception& e) {
80564       {
80565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80566       };
80567     } catch (Dali::DaliException e) {
80568       {
80569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80570       };
80571     } catch (...) {
80572       {
80573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80574       };
80575     }
80576   }
80577
80578   jresult = (void *)result;
80579   return jresult;
80580 }
80581
80582
80583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
80584   void * jresult ;
80585   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80586   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80587
80588   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80589   {
80590     try {
80591       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
80592     } catch (std::out_of_range& e) {
80593       {
80594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80595       };
80596     } catch (std::exception& e) {
80597       {
80598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80599       };
80600     } catch (Dali::DaliException e) {
80601       {
80602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80603       };
80604     } catch (...) {
80605       {
80606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80607       };
80608     }
80609   }
80610
80611   jresult = (void *)result;
80612   return jresult;
80613 }
80614
80615
80616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
80617   void * jresult ;
80618   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80619   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80620
80621   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80622   {
80623     try {
80624       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
80625     } catch (std::out_of_range& e) {
80626       {
80627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80628       };
80629     } catch (std::exception& e) {
80630       {
80631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80632       };
80633     } catch (Dali::DaliException e) {
80634       {
80635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80636       };
80637     } catch (...) {
80638       {
80639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80640       };
80641     }
80642   }
80643
80644   jresult = (void *)result;
80645   return jresult;
80646 }
80647
80648
80649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
80650   void * jresult ;
80651   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80652   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80653
80654   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80655   {
80656     try {
80657       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
80658     } catch (std::out_of_range& e) {
80659       {
80660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80661       };
80662     } catch (std::exception& e) {
80663       {
80664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80665       };
80666     } catch (Dali::DaliException e) {
80667       {
80668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80669       };
80670     } catch (...) {
80671       {
80672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80673       };
80674     }
80675   }
80676
80677   jresult = (void *)result;
80678   return jresult;
80679 }
80680
80681
80682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
80683   void * jresult ;
80684   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80685   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
80686
80687   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80688   {
80689     try {
80690       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
80691     } catch (std::out_of_range& e) {
80692       {
80693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80694       };
80695     } catch (std::exception& e) {
80696       {
80697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80698       };
80699     } catch (Dali::DaliException e) {
80700       {
80701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80702       };
80703     } catch (...) {
80704       {
80705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80706       };
80707     }
80708   }
80709
80710   jresult = (void *)result;
80711   return jresult;
80712 }
80713
80714
80715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
80716   void * jresult ;
80717   Dali::Toolkit::StyleManager *result = 0 ;
80718
80719   {
80720     try {
80721       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
80722     } catch (std::out_of_range& e) {
80723       {
80724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80725       };
80726     } catch (std::exception& e) {
80727       {
80728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80729       };
80730     } catch (Dali::DaliException e) {
80731       {
80732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80733       };
80734     } catch (...) {
80735       {
80736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80737       };
80738     }
80739   }
80740
80741   jresult = (void *)result;
80742   return jresult;
80743 }
80744
80745
80746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
80747   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80748
80749   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80750   {
80751     try {
80752       delete arg1;
80753     } catch (std::out_of_range& e) {
80754       {
80755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80756       };
80757     } catch (std::exception& e) {
80758       {
80759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80760       };
80761     } catch (Dali::DaliException e) {
80762       {
80763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80764       };
80765     } catch (...) {
80766       {
80767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80768       };
80769     }
80770   }
80771
80772 }
80773
80774
80775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
80776   void * jresult ;
80777   Dali::Toolkit::StyleManager result;
80778
80779   {
80780     try {
80781       result = Dali::Toolkit::StyleManager::Get();
80782     } catch (std::out_of_range& e) {
80783       {
80784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80785       };
80786     } catch (std::exception& e) {
80787       {
80788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80789       };
80790     } catch (Dali::DaliException e) {
80791       {
80792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80793       };
80794     } catch (...) {
80795       {
80796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80797       };
80798     }
80799   }
80800
80801   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
80802   return jresult;
80803 }
80804
80805
80806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
80807   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80808   std::string *arg2 = 0 ;
80809
80810   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80811   if (!jarg2) {
80812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80813     return ;
80814   }
80815   std::string arg2_str(jarg2);
80816   arg2 = &arg2_str;
80817   {
80818     try {
80819       (arg1)->ApplyTheme((std::string const &)*arg2);
80820     } catch (std::out_of_range& e) {
80821       {
80822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80823       };
80824     } catch (std::exception& e) {
80825       {
80826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80827       };
80828     } catch (Dali::DaliException e) {
80829       {
80830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80831       };
80832     } catch (...) {
80833       {
80834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80835       };
80836     }
80837   }
80838
80839
80840   //argout typemap for const std::string&
80841
80842 }
80843
80844
80845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
80846   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80847
80848   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80849   {
80850     try {
80851       (arg1)->ApplyDefaultTheme();
80852     } catch (std::out_of_range& e) {
80853       {
80854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80855       };
80856     } catch (std::exception& e) {
80857       {
80858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80859       };
80860     } catch (Dali::DaliException e) {
80861       {
80862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80863       };
80864     } catch (...) {
80865       {
80866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80867       };
80868     }
80869   }
80870
80871 }
80872
80873
80874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80875   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80876   std::string *arg2 = 0 ;
80877   Dali::Property::Value *arg3 = 0 ;
80878
80879   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80880   if (!jarg2) {
80881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80882     return ;
80883   }
80884   std::string arg2_str(jarg2);
80885   arg2 = &arg2_str;
80886   arg3 = (Dali::Property::Value *)jarg3;
80887   if (!arg3) {
80888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
80889     return ;
80890   }
80891   {
80892     try {
80893       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
80894     } catch (std::out_of_range& e) {
80895       {
80896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80897       };
80898     } catch (std::exception& e) {
80899       {
80900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80901       };
80902     } catch (Dali::DaliException e) {
80903       {
80904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80905       };
80906     } catch (...) {
80907       {
80908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80909       };
80910     }
80911   }
80912
80913
80914   //argout typemap for const std::string&
80915
80916 }
80917
80918
80919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80920   unsigned int jresult ;
80921   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80922   std::string *arg2 = 0 ;
80923   Dali::Property::Value *arg3 = 0 ;
80924   bool result;
80925
80926   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80927   if (!jarg2) {
80928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80929     return 0;
80930   }
80931   std::string arg2_str(jarg2);
80932   arg2 = &arg2_str;
80933   arg3 = (Dali::Property::Value *)jarg3;
80934   if (!arg3) {
80935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
80936     return 0;
80937   }
80938   {
80939     try {
80940       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
80941     } catch (std::out_of_range& e) {
80942       {
80943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80944       };
80945     } catch (std::exception& e) {
80946       {
80947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80948       };
80949     } catch (Dali::DaliException e) {
80950       {
80951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80952       };
80953     } catch (...) {
80954       {
80955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80956       };
80957     }
80958   }
80959
80960   jresult = result;
80961
80962   //argout typemap for const std::string&
80963
80964   return jresult;
80965 }
80966
80967
80968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
80969   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80970   Dali::Toolkit::Control arg2 ;
80971   std::string *arg3 = 0 ;
80972   std::string *arg4 = 0 ;
80973   Dali::Toolkit::Control *argp2 ;
80974
80975   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80976   argp2 = (Dali::Toolkit::Control *)jarg2;
80977   if (!argp2) {
80978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
80979     return ;
80980   }
80981   arg2 = *argp2;
80982   if (!jarg3) {
80983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80984     return ;
80985   }
80986   std::string arg3_str(jarg3);
80987   arg3 = &arg3_str;
80988   if (!jarg4) {
80989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80990     return ;
80991   }
80992   std::string arg4_str(jarg4);
80993   arg4 = &arg4_str;
80994   {
80995     try {
80996       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
80997     } catch (std::out_of_range& e) {
80998       {
80999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81000       };
81001     } catch (std::exception& e) {
81002       {
81003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81004       };
81005     } catch (Dali::DaliException e) {
81006       {
81007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81008       };
81009     } catch (...) {
81010       {
81011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81012       };
81013     }
81014   }
81015
81016
81017   //argout typemap for const std::string&
81018
81019
81020   //argout typemap for const std::string&
81021
81022 }
81023
81024
81025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
81026   void * jresult ;
81027   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81028   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
81029
81030   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81031   {
81032     try {
81033       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
81034     } catch (std::out_of_range& e) {
81035       {
81036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81037       };
81038     } catch (std::exception& e) {
81039       {
81040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81041       };
81042     } catch (Dali::DaliException e) {
81043       {
81044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81045       };
81046     } catch (...) {
81047       {
81048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81049       };
81050     }
81051   }
81052
81053   jresult = (void *)result;
81054   return jresult;
81055 }
81056
81057
81058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
81059   int jresult ;
81060   int result;
81061
81062   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
81063   jresult = (int)result;
81064   return jresult;
81065 }
81066
81067
81068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
81069   int jresult ;
81070   int result;
81071
81072   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
81073   jresult = (int)result;
81074   return jresult;
81075 }
81076
81077
81078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
81079   int jresult ;
81080   int result;
81081
81082   result = (int)Dali::Toolkit::Slider::Property::VALUE;
81083   jresult = (int)result;
81084   return jresult;
81085 }
81086
81087
81088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
81089   int jresult ;
81090   int result;
81091
81092   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
81093   jresult = (int)result;
81094   return jresult;
81095 }
81096
81097
81098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
81099   int jresult ;
81100   int result;
81101
81102   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
81103   jresult = (int)result;
81104   return jresult;
81105 }
81106
81107
81108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
81109   int jresult ;
81110   int result;
81111
81112   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
81113   jresult = (int)result;
81114   return jresult;
81115 }
81116
81117
81118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
81119   int jresult ;
81120   int result;
81121
81122   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
81123   jresult = (int)result;
81124   return jresult;
81125 }
81126
81127
81128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
81129   int jresult ;
81130   int result;
81131
81132   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
81133   jresult = (int)result;
81134   return jresult;
81135 }
81136
81137
81138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
81139   int jresult ;
81140   int result;
81141
81142   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
81143   jresult = (int)result;
81144   return jresult;
81145 }
81146
81147
81148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
81149   int jresult ;
81150   int result;
81151
81152   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
81153   jresult = (int)result;
81154   return jresult;
81155 }
81156
81157
81158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
81159   int jresult ;
81160   int result;
81161
81162   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
81163   jresult = (int)result;
81164   return jresult;
81165 }
81166
81167
81168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
81169   int jresult ;
81170   int result;
81171
81172   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
81173   jresult = (int)result;
81174   return jresult;
81175 }
81176
81177
81178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
81179   int jresult ;
81180   int result;
81181
81182   result = (int)Dali::Toolkit::Slider::Property::MARKS;
81183   jresult = (int)result;
81184   return jresult;
81185 }
81186
81187
81188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
81189   int jresult ;
81190   int result;
81191
81192   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
81193   jresult = (int)result;
81194   return jresult;
81195 }
81196
81197
81198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
81199   int jresult ;
81200   int result;
81201
81202   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
81203   jresult = (int)result;
81204   return jresult;
81205 }
81206
81207
81208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
81209   void * jresult ;
81210   Dali::Toolkit::Slider::Property *result = 0 ;
81211
81212   {
81213     try {
81214       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
81215     } catch (std::out_of_range& e) {
81216       {
81217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81218       };
81219     } catch (std::exception& e) {
81220       {
81221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81222       };
81223     } catch (Dali::DaliException e) {
81224       {
81225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81226       };
81227     } catch (...) {
81228       {
81229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81230       };
81231     }
81232   }
81233
81234   jresult = (void *)result;
81235   return jresult;
81236 }
81237
81238
81239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
81240   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
81241
81242   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
81243   {
81244     try {
81245       delete arg1;
81246     } catch (std::out_of_range& e) {
81247       {
81248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81249       };
81250     } catch (std::exception& e) {
81251       {
81252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81253       };
81254     } catch (Dali::DaliException e) {
81255       {
81256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81257       };
81258     } catch (...) {
81259       {
81260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81261       };
81262     }
81263   }
81264
81265 }
81266
81267
81268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
81269   void * jresult ;
81270   Dali::Toolkit::Slider result;
81271
81272   {
81273     try {
81274       result = Dali::Toolkit::Slider::New();
81275     } catch (std::out_of_range& e) {
81276       {
81277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81278       };
81279     } catch (std::exception& e) {
81280       {
81281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81282       };
81283     } catch (Dali::DaliException e) {
81284       {
81285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81286       };
81287     } catch (...) {
81288       {
81289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81290       };
81291     }
81292   }
81293
81294   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81295   return jresult;
81296 }
81297
81298
81299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
81300   void * jresult ;
81301   Dali::Toolkit::Slider *result = 0 ;
81302
81303   {
81304     try {
81305       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
81306     } catch (std::out_of_range& e) {
81307       {
81308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81309       };
81310     } catch (std::exception& e) {
81311       {
81312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81313       };
81314     } catch (Dali::DaliException e) {
81315       {
81316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81317       };
81318     } catch (...) {
81319       {
81320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81321       };
81322     }
81323   }
81324
81325   jresult = (void *)result;
81326   return jresult;
81327 }
81328
81329
81330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
81331   void * jresult ;
81332   Dali::Toolkit::Slider *arg1 = 0 ;
81333   Dali::Toolkit::Slider *result = 0 ;
81334
81335   arg1 = (Dali::Toolkit::Slider *)jarg1;
81336   if (!arg1) {
81337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81338     return 0;
81339   }
81340   {
81341     try {
81342       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
81343     } catch (std::out_of_range& e) {
81344       {
81345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81346       };
81347     } catch (std::exception& e) {
81348       {
81349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81350       };
81351     } catch (Dali::DaliException e) {
81352       {
81353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81354       };
81355     } catch (...) {
81356       {
81357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81358       };
81359     }
81360   }
81361
81362   jresult = (void *)result;
81363   return jresult;
81364 }
81365
81366
81367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
81368   void * jresult ;
81369   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81370   Dali::Toolkit::Slider *arg2 = 0 ;
81371   Dali::Toolkit::Slider *result = 0 ;
81372
81373   arg1 = (Dali::Toolkit::Slider *)jarg1;
81374   arg2 = (Dali::Toolkit::Slider *)jarg2;
81375   if (!arg2) {
81376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81377     return 0;
81378   }
81379   {
81380     try {
81381       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
81382     } catch (std::out_of_range& e) {
81383       {
81384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81385       };
81386     } catch (std::exception& e) {
81387       {
81388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81389       };
81390     } catch (Dali::DaliException e) {
81391       {
81392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81393       };
81394     } catch (...) {
81395       {
81396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81397       };
81398     }
81399   }
81400
81401   jresult = (void *)result;
81402   return jresult;
81403 }
81404
81405
81406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
81407   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81408
81409   arg1 = (Dali::Toolkit::Slider *)jarg1;
81410   {
81411     try {
81412       delete arg1;
81413     } catch (std::out_of_range& e) {
81414       {
81415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81416       };
81417     } catch (std::exception& e) {
81418       {
81419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81420       };
81421     } catch (Dali::DaliException e) {
81422       {
81423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81424       };
81425     } catch (...) {
81426       {
81427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81428       };
81429     }
81430   }
81431
81432 }
81433
81434
81435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
81436   void * jresult ;
81437   Dali::BaseHandle arg1 ;
81438   Dali::BaseHandle *argp1 ;
81439   Dali::Toolkit::Slider result;
81440
81441   argp1 = (Dali::BaseHandle *)jarg1;
81442   if (!argp1) {
81443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81444     return 0;
81445   }
81446   arg1 = *argp1;
81447   {
81448     try {
81449       result = Dali::Toolkit::Slider::DownCast(arg1);
81450     } catch (std::out_of_range& e) {
81451       {
81452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81453       };
81454     } catch (std::exception& e) {
81455       {
81456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81457       };
81458     } catch (Dali::DaliException e) {
81459       {
81460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81461       };
81462     } catch (...) {
81463       {
81464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81465       };
81466     }
81467   }
81468
81469   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81470   return jresult;
81471 }
81472
81473
81474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
81475   void * jresult ;
81476   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81477   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81478
81479   arg1 = (Dali::Toolkit::Slider *)jarg1;
81480   {
81481     try {
81482       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
81483     } catch (std::out_of_range& e) {
81484       {
81485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81486       };
81487     } catch (std::exception& e) {
81488       {
81489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81490       };
81491     } catch (Dali::DaliException e) {
81492       {
81493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81494       };
81495     } catch (...) {
81496       {
81497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81498       };
81499     }
81500   }
81501
81502   jresult = (void *)result;
81503   return jresult;
81504 }
81505
81506
81507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
81508   void * jresult ;
81509   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81510   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81511
81512   arg1 = (Dali::Toolkit::Slider *)jarg1;
81513   {
81514     try {
81515       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
81516     } catch (std::out_of_range& e) {
81517       {
81518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81519       };
81520     } catch (std::exception& e) {
81521       {
81522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81523       };
81524     } catch (Dali::DaliException e) {
81525       {
81526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81527       };
81528     } catch (...) {
81529       {
81530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81531       };
81532     }
81533   }
81534
81535   jresult = (void *)result;
81536   return jresult;
81537 }
81538
81539
81540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
81541   void * jresult ;
81542   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81543   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
81544
81545   arg1 = (Dali::Toolkit::Slider *)jarg1;
81546   {
81547     try {
81548       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
81549     } catch (std::out_of_range& e) {
81550       {
81551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81552       };
81553     } catch (std::exception& e) {
81554       {
81555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81556       };
81557     } catch (Dali::DaliException e) {
81558       {
81559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81560       };
81561     } catch (...) {
81562       {
81563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81564       };
81565     }
81566   }
81567
81568   jresult = (void *)result;
81569   return jresult;
81570 }
81571
81572
81573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
81574   int jresult ;
81575   int result;
81576
81577   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
81578   jresult = (int)result;
81579   return jresult;
81580 }
81581
81582
81583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
81584   int jresult ;
81585   int result;
81586
81587   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
81588   jresult = (int)result;
81589   return jresult;
81590 }
81591
81592
81593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
81594   int jresult ;
81595   int result;
81596
81597   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
81598   jresult = (int)result;
81599   return jresult;
81600 }
81601
81602
81603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
81604   int jresult ;
81605   int result;
81606
81607   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
81608   jresult = (int)result;
81609   return jresult;
81610 }
81611
81612
81613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
81614   int result;
81615
81616   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
81617
81618   return result;
81619 }
81620
81621
81622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
81623   void * jresult ;
81624   Dali::Toolkit::VideoView::Property *result = 0 ;
81625
81626   {
81627     try {
81628       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
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 void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
81654   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
81655
81656   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
81657   {
81658     try {
81659       delete arg1;
81660     } catch (std::out_of_range& e) {
81661       {
81662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81663       };
81664     } catch (std::exception& e) {
81665       {
81666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81667       };
81668     } catch (Dali::DaliException e) {
81669       {
81670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81671       };
81672     } catch (...) {
81673       {
81674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81675       };
81676     }
81677   }
81678
81679 }
81680
81681
81682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
81683   void * jresult ;
81684   Dali::Toolkit::VideoView result;
81685
81686   {
81687     try {
81688       result = Dali::Toolkit::VideoView::New();
81689     } catch (std::out_of_range& e) {
81690       {
81691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81692       };
81693     } catch (std::exception& e) {
81694       {
81695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81696       };
81697     } catch (Dali::DaliException e) {
81698       {
81699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81700       };
81701     } catch (...) {
81702       {
81703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81704       };
81705     }
81706   }
81707
81708   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81709   return jresult;
81710 }
81711
81712
81713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
81714   void * jresult ;
81715   std::string *arg1 = 0 ;
81716   Dali::Toolkit::VideoView result;
81717
81718   if (!jarg1) {
81719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81720     return 0;
81721   }
81722   std::string arg1_str(jarg1);
81723   arg1 = &arg1_str;
81724   {
81725     try {
81726       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
81727     } catch (std::out_of_range& e) {
81728       {
81729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81730       };
81731     } catch (std::exception& e) {
81732       {
81733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81734       };
81735     } catch (Dali::DaliException e) {
81736       {
81737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81738       };
81739     } catch (...) {
81740       {
81741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81742       };
81743     }
81744   }
81745
81746   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81747
81748   //argout typemap for const std::string&
81749
81750   return jresult;
81751 }
81752
81753
81754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
81755   void * jresult ;
81756   Dali::Toolkit::VideoView result;
81757   {
81758     try {
81759       result = Dali::Toolkit::VideoView::New(swCodec);
81760     } catch (std::out_of_range& e) {
81761       {
81762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81763       };
81764     } catch (std::exception& e) {
81765       {
81766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81767       };
81768     } catch (Dali::DaliException e) {
81769       {
81770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81771       };
81772     } catch (...) {
81773       {
81774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81775       };
81776     }
81777   }
81778
81779   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81780
81781   //argout typemap for const std::string&
81782
81783   return jresult;
81784 }
81785
81786
81787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
81788   void * jresult ;
81789   std::string *arg1 = 0 ;
81790   Dali::Toolkit::VideoView result;
81791
81792   if (!jarg1) {
81793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81794     return 0;
81795   }
81796   std::string arg1_str(jarg1);
81797   arg1 = &arg1_str;
81798   {
81799     try {
81800       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
81801     } catch (std::out_of_range& e) {
81802       {
81803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81804       };
81805     } catch (std::exception& e) {
81806       {
81807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81808       };
81809     } catch (Dali::DaliException e) {
81810       {
81811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81812       };
81813     } catch (...) {
81814       {
81815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81816       };
81817     }
81818   }
81819
81820   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81821
81822   //argout typemap for const std::string&
81823
81824   return jresult;
81825 }
81826
81827
81828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
81829   void * jresult ;
81830   Dali::Toolkit::VideoView *result = 0 ;
81831
81832   {
81833     try {
81834       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
81835     } catch (std::out_of_range& e) {
81836       {
81837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81838       };
81839     } catch (std::exception& e) {
81840       {
81841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81842       };
81843     } catch (Dali::DaliException e) {
81844       {
81845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81846       };
81847     } catch (...) {
81848       {
81849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81850       };
81851     }
81852   }
81853
81854   jresult = (void *)result;
81855   return jresult;
81856 }
81857
81858
81859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
81860   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81861
81862   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81863   {
81864     try {
81865       delete arg1;
81866     } catch (std::out_of_range& e) {
81867       {
81868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81869       };
81870     } catch (std::exception& e) {
81871       {
81872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81873       };
81874     } catch (Dali::DaliException e) {
81875       {
81876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81877       };
81878     } catch (...) {
81879       {
81880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81881       };
81882     }
81883   }
81884
81885 }
81886
81887
81888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
81889   void * jresult ;
81890   Dali::Toolkit::VideoView *arg1 = 0 ;
81891   Dali::Toolkit::VideoView *result = 0 ;
81892
81893   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81894   if (!arg1) {
81895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
81896     return 0;
81897   }
81898   {
81899     try {
81900       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
81901     } catch (std::out_of_range& e) {
81902       {
81903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81904       };
81905     } catch (std::exception& e) {
81906       {
81907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81908       };
81909     } catch (Dali::DaliException e) {
81910       {
81911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81912       };
81913     } catch (...) {
81914       {
81915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81916       };
81917     }
81918   }
81919
81920   jresult = (void *)result;
81921   return jresult;
81922 }
81923
81924
81925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
81926   void * jresult ;
81927   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81928   Dali::Toolkit::VideoView *arg2 = 0 ;
81929   Dali::Toolkit::VideoView *result = 0 ;
81930
81931   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81932   arg2 = (Dali::Toolkit::VideoView *)jarg2;
81933   if (!arg2) {
81934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
81935     return 0;
81936   }
81937   {
81938     try {
81939       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
81940     } catch (std::out_of_range& e) {
81941       {
81942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81943       };
81944     } catch (std::exception& e) {
81945       {
81946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81947       };
81948     } catch (Dali::DaliException e) {
81949       {
81950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81951       };
81952     } catch (...) {
81953       {
81954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81955       };
81956     }
81957   }
81958
81959   jresult = (void *)result;
81960   return jresult;
81961 }
81962
81963
81964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
81965   void * jresult ;
81966   Dali::BaseHandle arg1 ;
81967   Dali::BaseHandle *argp1 ;
81968   Dali::Toolkit::VideoView result;
81969
81970   argp1 = (Dali::BaseHandle *)jarg1;
81971   if (!argp1) {
81972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81973     return 0;
81974   }
81975   arg1 = *argp1;
81976   {
81977     try {
81978       result = Dali::Toolkit::VideoView::DownCast(arg1);
81979     } catch (std::out_of_range& e) {
81980       {
81981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81982       };
81983     } catch (std::exception& e) {
81984       {
81985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81986       };
81987     } catch (Dali::DaliException e) {
81988       {
81989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81990       };
81991     } catch (...) {
81992       {
81993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81994       };
81995     }
81996   }
81997
81998   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81999   return jresult;
82000 }
82001
82002
82003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
82004   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82005
82006   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82007   {
82008     try {
82009       (arg1)->Play();
82010     } catch (std::out_of_range& e) {
82011       {
82012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82013       };
82014     } catch (std::exception& e) {
82015       {
82016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82017       };
82018     } catch (Dali::DaliException e) {
82019       {
82020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82021       };
82022     } catch (...) {
82023       {
82024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82025       };
82026     }
82027   }
82028
82029 }
82030
82031
82032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
82033   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82034
82035   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82036   {
82037     try {
82038       (arg1)->Pause();
82039     } catch (std::out_of_range& e) {
82040       {
82041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82042       };
82043     } catch (std::exception& e) {
82044       {
82045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82046       };
82047     } catch (Dali::DaliException e) {
82048       {
82049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82050       };
82051     } catch (...) {
82052       {
82053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82054       };
82055     }
82056   }
82057
82058 }
82059
82060
82061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
82062   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82063
82064   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82065   {
82066     try {
82067       (arg1)->Stop();
82068     } catch (std::out_of_range& e) {
82069       {
82070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82071       };
82072     } catch (std::exception& e) {
82073       {
82074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82075       };
82076     } catch (Dali::DaliException e) {
82077       {
82078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82079       };
82080     } catch (...) {
82081       {
82082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82083       };
82084     }
82085   }
82086
82087 }
82088
82089
82090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
82091   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82092   int arg2 ;
82093
82094   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82095   arg2 = (int)jarg2;
82096   {
82097     try {
82098       (arg1)->Forward(arg2);
82099     } catch (std::out_of_range& e) {
82100       {
82101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82102       };
82103     } catch (std::exception& e) {
82104       {
82105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82106       };
82107     } catch (Dali::DaliException e) {
82108       {
82109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82110       };
82111     } catch (...) {
82112       {
82113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82114       };
82115     }
82116   }
82117
82118 }
82119
82120
82121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
82122   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82123   int arg2 ;
82124
82125   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82126   arg2 = (int)jarg2;
82127   {
82128     try {
82129       (arg1)->Backward(arg2);
82130     } catch (std::out_of_range& e) {
82131       {
82132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82133       };
82134     } catch (std::exception& e) {
82135       {
82136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82137       };
82138     } catch (Dali::DaliException e) {
82139       {
82140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82141       };
82142     } catch (...) {
82143       {
82144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82145       };
82146     }
82147   }
82148
82149 }
82150
82151
82152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
82153   void * jresult ;
82154   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82155   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
82156
82157   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82158   {
82159     try {
82160       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
82161     } catch (std::out_of_range& e) {
82162       {
82163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82164       };
82165     } catch (std::exception& e) {
82166       {
82167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82168       };
82169     } catch (Dali::DaliException e) {
82170       {
82171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82172       };
82173     } catch (...) {
82174       {
82175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82176       };
82177     }
82178   }
82179
82180   jresult = (void *)result;
82181   return jresult;
82182 }
82183
82184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
82185 {
82186   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
82187   if( arg1 == nullptr )
82188   {
82189     DALI_LOG_ERROR("VideoView is nullptr!");
82190     return nullptr;
82191   }
82192   void * ret = nullptr;
82193   {
82194     try{
82195
82196       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
82197       ret = Dali::AnyCast< void * >( result );
82198
82199     } catch (std::out_of_range& e) {
82200       {
82201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82202       };
82203     } catch (std::exception& e) {
82204       {
82205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82206       };
82207     } catch (Dali::DaliException e) {
82208       {
82209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82210       };
82211     } catch (...) {
82212       {
82213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82214       };
82215     }
82216   }
82217   return ret;
82218 }
82219
82220
82221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
82222   int jresult ;
82223   int result;
82224
82225   result = (int)Dali::Toolkit::Popup::Property::TITLE;
82226   jresult = (int)result;
82227   return jresult;
82228 }
82229
82230
82231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
82232   int jresult ;
82233   int result;
82234
82235   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
82236   jresult = (int)result;
82237   return jresult;
82238 }
82239
82240
82241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
82242   int jresult ;
82243   int result;
82244
82245   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
82246   jresult = (int)result;
82247   return jresult;
82248 }
82249
82250
82251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
82252   int jresult ;
82253   int result;
82254
82255   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
82256   jresult = (int)result;
82257   return jresult;
82258 }
82259
82260
82261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
82262   int jresult ;
82263   int result;
82264
82265   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
82266   jresult = (int)result;
82267   return jresult;
82268 }
82269
82270
82271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
82272   int jresult ;
82273   int result;
82274
82275   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
82276   jresult = (int)result;
82277   return jresult;
82278 }
82279
82280
82281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
82282   int jresult ;
82283   int result;
82284
82285   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
82286   jresult = (int)result;
82287   return jresult;
82288 }
82289
82290
82291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
82292   int jresult ;
82293   int result;
82294
82295   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
82296   jresult = (int)result;
82297   return jresult;
82298 }
82299
82300
82301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
82302   int jresult ;
82303   int result;
82304
82305   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
82306   jresult = (int)result;
82307   return jresult;
82308 }
82309
82310
82311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
82312   int jresult ;
82313   int result;
82314
82315   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
82316   jresult = (int)result;
82317   return jresult;
82318 }
82319
82320
82321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
82322   int jresult ;
82323   int result;
82324
82325   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
82326   jresult = (int)result;
82327   return jresult;
82328 }
82329
82330
82331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
82332   int jresult ;
82333   int result;
82334
82335   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
82336   jresult = (int)result;
82337   return jresult;
82338 }
82339
82340
82341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
82342   int jresult ;
82343   int result;
82344
82345   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
82346   jresult = (int)result;
82347   return jresult;
82348 }
82349
82350
82351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
82352   int jresult ;
82353   int result;
82354
82355   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
82356   jresult = (int)result;
82357   return jresult;
82358 }
82359
82360
82361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
82362   int jresult ;
82363   int result;
82364
82365   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
82366   jresult = (int)result;
82367   return jresult;
82368 }
82369
82370
82371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
82372   int jresult ;
82373   int result;
82374
82375   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
82376   jresult = (int)result;
82377   return jresult;
82378 }
82379
82380
82381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
82382   int jresult ;
82383   int result;
82384
82385   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
82386   jresult = (int)result;
82387   return jresult;
82388 }
82389
82390
82391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
82392   int jresult ;
82393   int result;
82394
82395   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
82396   jresult = (int)result;
82397   return jresult;
82398 }
82399
82400
82401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
82402   int jresult ;
82403   int result;
82404
82405   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
82406   jresult = (int)result;
82407   return jresult;
82408 }
82409
82410
82411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
82412   int jresult ;
82413   int result;
82414
82415   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
82416   jresult = (int)result;
82417   return jresult;
82418 }
82419
82420
82421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
82422   int jresult ;
82423   int result;
82424
82425   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
82426   jresult = (int)result;
82427   return jresult;
82428 }
82429
82430
82431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
82432   void * jresult ;
82433   Dali::Toolkit::Popup::Property *result = 0 ;
82434
82435   {
82436     try {
82437       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
82438     } catch (std::out_of_range& e) {
82439       {
82440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82441       };
82442     } catch (std::exception& e) {
82443       {
82444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82445       };
82446     } catch (Dali::DaliException e) {
82447       {
82448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82449       };
82450     } catch (...) {
82451       {
82452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82453       };
82454     }
82455   }
82456
82457   jresult = (void *)result;
82458   return jresult;
82459 }
82460
82461
82462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
82463   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
82464
82465   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
82466   {
82467     try {
82468       delete arg1;
82469     } catch (std::out_of_range& e) {
82470       {
82471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82472       };
82473     } catch (std::exception& e) {
82474       {
82475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82476       };
82477     } catch (Dali::DaliException e) {
82478       {
82479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82480       };
82481     } catch (...) {
82482       {
82483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82484       };
82485     }
82486   }
82487
82488 }
82489
82490
82491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
82492   void * jresult ;
82493   Dali::Toolkit::Popup *result = 0 ;
82494
82495   {
82496     try {
82497       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
82498     } catch (std::out_of_range& e) {
82499       {
82500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82501       };
82502     } catch (std::exception& e) {
82503       {
82504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82505       };
82506     } catch (Dali::DaliException e) {
82507       {
82508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82509       };
82510     } catch (...) {
82511       {
82512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82513       };
82514     }
82515   }
82516
82517   jresult = (void *)result;
82518   return jresult;
82519 }
82520
82521
82522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
82523   void * jresult ;
82524   Dali::Toolkit::Popup result;
82525
82526   {
82527     try {
82528       result = Dali::Toolkit::Popup::New();
82529     } catch (std::out_of_range& e) {
82530       {
82531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82532       };
82533     } catch (std::exception& e) {
82534       {
82535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82536       };
82537     } catch (Dali::DaliException e) {
82538       {
82539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82540       };
82541     } catch (...) {
82542       {
82543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82544       };
82545     }
82546   }
82547
82548   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82549   return jresult;
82550 }
82551
82552
82553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
82554   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82555
82556   arg1 = (Dali::Toolkit::Popup *)jarg1;
82557   {
82558     try {
82559       delete arg1;
82560     } catch (std::out_of_range& e) {
82561       {
82562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82563       };
82564     } catch (std::exception& e) {
82565       {
82566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82567       };
82568     } catch (Dali::DaliException e) {
82569       {
82570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82571       };
82572     } catch (...) {
82573       {
82574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82575       };
82576     }
82577   }
82578
82579 }
82580
82581
82582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
82583   void * jresult ;
82584   Dali::Toolkit::Popup *arg1 = 0 ;
82585   Dali::Toolkit::Popup *result = 0 ;
82586
82587   arg1 = (Dali::Toolkit::Popup *)jarg1;
82588   if (!arg1) {
82589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82590     return 0;
82591   }
82592   {
82593     try {
82594       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
82595     } catch (std::out_of_range& e) {
82596       {
82597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82598       };
82599     } catch (std::exception& e) {
82600       {
82601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82602       };
82603     } catch (Dali::DaliException e) {
82604       {
82605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82606       };
82607     } catch (...) {
82608       {
82609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82610       };
82611     }
82612   }
82613
82614   jresult = (void *)result;
82615   return jresult;
82616 }
82617
82618
82619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
82620   void * jresult ;
82621   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82622   Dali::Toolkit::Popup *arg2 = 0 ;
82623   Dali::Toolkit::Popup *result = 0 ;
82624
82625   arg1 = (Dali::Toolkit::Popup *)jarg1;
82626   arg2 = (Dali::Toolkit::Popup *)jarg2;
82627   if (!arg2) {
82628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82629     return 0;
82630   }
82631   {
82632     try {
82633       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
82634     } catch (std::out_of_range& e) {
82635       {
82636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82637       };
82638     } catch (std::exception& e) {
82639       {
82640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82641       };
82642     } catch (Dali::DaliException e) {
82643       {
82644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82645       };
82646     } catch (...) {
82647       {
82648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82649       };
82650     }
82651   }
82652
82653   jresult = (void *)result;
82654   return jresult;
82655 }
82656
82657
82658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
82659   void * jresult ;
82660   Dali::BaseHandle arg1 ;
82661   Dali::BaseHandle *argp1 ;
82662   Dali::Toolkit::Popup result;
82663
82664   argp1 = (Dali::BaseHandle *)jarg1;
82665   if (!argp1) {
82666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82667     return 0;
82668   }
82669   arg1 = *argp1;
82670   {
82671     try {
82672       result = Dali::Toolkit::Popup::DownCast(arg1);
82673     } catch (std::out_of_range& e) {
82674       {
82675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82676       };
82677     } catch (std::exception& e) {
82678       {
82679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82680       };
82681     } catch (Dali::DaliException e) {
82682       {
82683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82684       };
82685     } catch (...) {
82686       {
82687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82688       };
82689     }
82690   }
82691
82692   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82693   return jresult;
82694 }
82695
82696
82697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
82698   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82699   Dali::Actor arg2 ;
82700   Dali::Actor *argp2 ;
82701
82702   arg1 = (Dali::Toolkit::Popup *)jarg1;
82703   argp2 = (Dali::Actor *)jarg2;
82704   if (!argp2) {
82705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82706     return ;
82707   }
82708   arg2 = *argp2;
82709   {
82710     try {
82711       (arg1)->SetTitle(arg2);
82712     } catch (std::out_of_range& e) {
82713       {
82714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82715       };
82716     } catch (std::exception& e) {
82717       {
82718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82719       };
82720     } catch (Dali::DaliException e) {
82721       {
82722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82723       };
82724     } catch (...) {
82725       {
82726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82727       };
82728     }
82729   }
82730
82731 }
82732
82733
82734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
82735   void * jresult ;
82736   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82737   Dali::Actor result;
82738
82739   arg1 = (Dali::Toolkit::Popup *)jarg1;
82740   {
82741     try {
82742       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
82743     } catch (std::out_of_range& e) {
82744       {
82745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82746       };
82747     } catch (std::exception& e) {
82748       {
82749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82750       };
82751     } catch (Dali::DaliException e) {
82752       {
82753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82754       };
82755     } catch (...) {
82756       {
82757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82758       };
82759     }
82760   }
82761
82762   jresult = new Dali::Actor((const Dali::Actor &)result);
82763   return jresult;
82764 }
82765
82766
82767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
82768   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82769   Dali::Actor arg2 ;
82770   Dali::Actor *argp2 ;
82771
82772   arg1 = (Dali::Toolkit::Popup *)jarg1;
82773   argp2 = (Dali::Actor *)jarg2;
82774   if (!argp2) {
82775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82776     return ;
82777   }
82778   arg2 = *argp2;
82779   {
82780     try {
82781       (arg1)->SetContent(arg2);
82782     } catch (std::out_of_range& e) {
82783       {
82784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82785       };
82786     } catch (std::exception& e) {
82787       {
82788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82789       };
82790     } catch (Dali::DaliException e) {
82791       {
82792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82793       };
82794     } catch (...) {
82795       {
82796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82797       };
82798     }
82799   }
82800
82801 }
82802
82803
82804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
82805   void * jresult ;
82806   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82807   Dali::Actor result;
82808
82809   arg1 = (Dali::Toolkit::Popup *)jarg1;
82810   {
82811     try {
82812       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
82813     } catch (std::out_of_range& e) {
82814       {
82815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82816       };
82817     } catch (std::exception& e) {
82818       {
82819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82820       };
82821     } catch (Dali::DaliException e) {
82822       {
82823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82824       };
82825     } catch (...) {
82826       {
82827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82828       };
82829     }
82830   }
82831
82832   jresult = new Dali::Actor((const Dali::Actor &)result);
82833   return jresult;
82834 }
82835
82836
82837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
82838   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82839   Dali::Actor arg2 ;
82840   Dali::Actor *argp2 ;
82841
82842   arg1 = (Dali::Toolkit::Popup *)jarg1;
82843   argp2 = (Dali::Actor *)jarg2;
82844   if (!argp2) {
82845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82846     return ;
82847   }
82848   arg2 = *argp2;
82849   {
82850     try {
82851       (arg1)->SetFooter(arg2);
82852     } catch (std::out_of_range& e) {
82853       {
82854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82855       };
82856     } catch (std::exception& e) {
82857       {
82858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82859       };
82860     } catch (Dali::DaliException e) {
82861       {
82862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82863       };
82864     } catch (...) {
82865       {
82866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82867       };
82868     }
82869   }
82870
82871 }
82872
82873
82874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
82875   void * jresult ;
82876   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82877   Dali::Actor result;
82878
82879   arg1 = (Dali::Toolkit::Popup *)jarg1;
82880   {
82881     try {
82882       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
82883     } catch (std::out_of_range& e) {
82884       {
82885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82886       };
82887     } catch (std::exception& e) {
82888       {
82889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82890       };
82891     } catch (Dali::DaliException e) {
82892       {
82893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82894       };
82895     } catch (...) {
82896       {
82897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82898       };
82899     }
82900   }
82901
82902   jresult = new Dali::Actor((const Dali::Actor &)result);
82903   return jresult;
82904 }
82905
82906
82907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
82908   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82909   Dali::Toolkit::Popup::DisplayState arg2 ;
82910
82911   arg1 = (Dali::Toolkit::Popup *)jarg1;
82912   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
82913   {
82914     try {
82915       (arg1)->SetDisplayState(arg2);
82916     } catch (std::out_of_range& e) {
82917       {
82918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82919       };
82920     } catch (std::exception& e) {
82921       {
82922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82923       };
82924     } catch (Dali::DaliException e) {
82925       {
82926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82927       };
82928     } catch (...) {
82929       {
82930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82931       };
82932     }
82933   }
82934
82935 }
82936
82937
82938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
82939   int jresult ;
82940   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82941   Dali::Toolkit::Popup::DisplayState result;
82942
82943   arg1 = (Dali::Toolkit::Popup *)jarg1;
82944   {
82945     try {
82946       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
82947     } catch (std::out_of_range& e) {
82948       {
82949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82950       };
82951     } catch (std::exception& e) {
82952       {
82953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82954       };
82955     } catch (Dali::DaliException e) {
82956       {
82957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82958       };
82959     } catch (...) {
82960       {
82961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82962       };
82963     }
82964   }
82965
82966   jresult = (int)result;
82967   return jresult;
82968 }
82969
82970
82971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
82972   void * jresult ;
82973   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82974   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
82975
82976   arg1 = (Dali::Toolkit::Popup *)jarg1;
82977   {
82978     try {
82979       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
82980     } catch (std::out_of_range& e) {
82981       {
82982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82983       };
82984     } catch (std::exception& e) {
82985       {
82986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82987       };
82988     } catch (Dali::DaliException e) {
82989       {
82990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82991       };
82992     } catch (...) {
82993       {
82994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82995       };
82996     }
82997   }
82998
82999   jresult = (void *)result;
83000   return jresult;
83001 }
83002
83003
83004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
83005   void * jresult ;
83006   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83007   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83008
83009   arg1 = (Dali::Toolkit::Popup *)jarg1;
83010   {
83011     try {
83012       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
83013     } catch (std::out_of_range& e) {
83014       {
83015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83016       };
83017     } catch (std::exception& e) {
83018       {
83019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83020       };
83021     } catch (Dali::DaliException e) {
83022       {
83023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83024       };
83025     } catch (...) {
83026       {
83027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83028       };
83029     }
83030   }
83031
83032   jresult = (void *)result;
83033   return jresult;
83034 }
83035
83036
83037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
83038   void * jresult ;
83039   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83040   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83041
83042   arg1 = (Dali::Toolkit::Popup *)jarg1;
83043   {
83044     try {
83045       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
83046     } catch (std::out_of_range& e) {
83047       {
83048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83049       };
83050     } catch (std::exception& e) {
83051       {
83052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83053       };
83054     } catch (Dali::DaliException e) {
83055       {
83056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83057       };
83058     } catch (...) {
83059       {
83060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83061       };
83062     }
83063   }
83064
83065   jresult = (void *)result;
83066   return jresult;
83067 }
83068
83069
83070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
83071   void * jresult ;
83072   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83073   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83074
83075   arg1 = (Dali::Toolkit::Popup *)jarg1;
83076   {
83077     try {
83078       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
83079     } catch (std::out_of_range& e) {
83080       {
83081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83082       };
83083     } catch (std::exception& e) {
83084       {
83085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83086       };
83087     } catch (Dali::DaliException e) {
83088       {
83089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83090       };
83091     } catch (...) {
83092       {
83093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83094       };
83095     }
83096   }
83097
83098   jresult = (void *)result;
83099   return jresult;
83100 }
83101
83102
83103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
83104   void * jresult ;
83105   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83106   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83107
83108   arg1 = (Dali::Toolkit::Popup *)jarg1;
83109   {
83110     try {
83111       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
83112     } catch (std::out_of_range& e) {
83113       {
83114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83115       };
83116     } catch (std::exception& e) {
83117       {
83118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83119       };
83120     } catch (Dali::DaliException e) {
83121       {
83122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83123       };
83124     } catch (...) {
83125       {
83126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83127       };
83128     }
83129   }
83130
83131   jresult = (void *)result;
83132   return jresult;
83133 }
83134
83135
83136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
83137   int jresult ;
83138   int result;
83139
83140   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
83141   jresult = (int)result;
83142   return jresult;
83143 }
83144
83145
83146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
83147   int jresult ;
83148   int result;
83149
83150   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
83151   jresult = (int)result;
83152   return jresult;
83153 }
83154
83155
83156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
83157   int jresult ;
83158   int result;
83159
83160   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
83161   jresult = (int)result;
83162   return jresult;
83163 }
83164
83165
83166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
83167   int jresult ;
83168   int result;
83169
83170   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
83171   jresult = (int)result;
83172   return jresult;
83173 }
83174
83175
83176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
83177   int jresult ;
83178   int result;
83179
83180   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
83181   jresult = (int)result;
83182   return jresult;
83183 }
83184
83185
83186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
83187   int jresult ;
83188   int result;
83189
83190   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
83191   jresult = (int)result;
83192   return jresult;
83193 }
83194
83195
83196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
83197   int jresult ;
83198   int result;
83199
83200   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
83201   jresult = (int)result;
83202   return jresult;
83203 }
83204
83205
83206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
83207   int jresult ;
83208   int result;
83209
83210   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
83211   jresult = (int)result;
83212   return jresult;
83213 }
83214
83215
83216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
83217   int jresult ;
83218   int result;
83219
83220   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
83221   jresult = (int)result;
83222   return jresult;
83223 }
83224
83225
83226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
83227   void * jresult ;
83228   Dali::Toolkit::ProgressBar::Property *result = 0 ;
83229
83230   {
83231     try {
83232       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
83233     } catch (std::out_of_range& e) {
83234       {
83235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83236       };
83237     } catch (std::exception& e) {
83238       {
83239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83240       };
83241     } catch (Dali::DaliException e) {
83242       {
83243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83244       };
83245     } catch (...) {
83246       {
83247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83248       };
83249     }
83250   }
83251
83252   jresult = (void *)result;
83253   return jresult;
83254 }
83255
83256
83257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
83258   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
83259
83260   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
83261   {
83262     try {
83263       delete arg1;
83264     } catch (std::out_of_range& e) {
83265       {
83266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83267       };
83268     } catch (std::exception& e) {
83269       {
83270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83271       };
83272     } catch (Dali::DaliException e) {
83273       {
83274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83275       };
83276     } catch (...) {
83277       {
83278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83279       };
83280     }
83281   }
83282
83283 }
83284
83285
83286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
83287   void * jresult ;
83288   Dali::Toolkit::ProgressBar result;
83289
83290   {
83291     try {
83292       result = Dali::Toolkit::ProgressBar::New();
83293     } catch (std::out_of_range& e) {
83294       {
83295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83296       };
83297     } catch (std::exception& e) {
83298       {
83299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83300       };
83301     } catch (Dali::DaliException e) {
83302       {
83303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83304       };
83305     } catch (...) {
83306       {
83307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83308       };
83309     }
83310   }
83311
83312   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83313   return jresult;
83314 }
83315
83316
83317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
83318   void * jresult ;
83319   Dali::Toolkit::ProgressBar *result = 0 ;
83320
83321   {
83322     try {
83323       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
83324     } catch (std::out_of_range& e) {
83325       {
83326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83327       };
83328     } catch (std::exception& e) {
83329       {
83330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83331       };
83332     } catch (Dali::DaliException e) {
83333       {
83334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83335       };
83336     } catch (...) {
83337       {
83338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83339       };
83340     }
83341   }
83342
83343   jresult = (void *)result;
83344   return jresult;
83345 }
83346
83347
83348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
83349   void * jresult ;
83350   Dali::Toolkit::ProgressBar *arg1 = 0 ;
83351   Dali::Toolkit::ProgressBar *result = 0 ;
83352
83353   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83354   if (!arg1) {
83355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83356     return 0;
83357   }
83358   {
83359     try {
83360       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
83361     } catch (std::out_of_range& e) {
83362       {
83363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83364       };
83365     } catch (std::exception& e) {
83366       {
83367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83368       };
83369     } catch (Dali::DaliException e) {
83370       {
83371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83372       };
83373     } catch (...) {
83374       {
83375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83376       };
83377     }
83378   }
83379
83380   jresult = (void *)result;
83381   return jresult;
83382 }
83383
83384
83385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
83386   void * jresult ;
83387   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83388   Dali::Toolkit::ProgressBar *arg2 = 0 ;
83389   Dali::Toolkit::ProgressBar *result = 0 ;
83390
83391   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83392   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
83393   if (!arg2) {
83394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83395     return 0;
83396   }
83397   {
83398     try {
83399       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
83400     } catch (std::out_of_range& e) {
83401       {
83402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83403       };
83404     } catch (std::exception& e) {
83405       {
83406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83407       };
83408     } catch (Dali::DaliException e) {
83409       {
83410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83411       };
83412     } catch (...) {
83413       {
83414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83415       };
83416     }
83417   }
83418
83419   jresult = (void *)result;
83420   return jresult;
83421 }
83422
83423
83424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
83425   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83426
83427   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83428   {
83429     try {
83430       delete arg1;
83431     } catch (std::out_of_range& e) {
83432       {
83433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83434       };
83435     } catch (std::exception& e) {
83436       {
83437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83438       };
83439     } catch (Dali::DaliException e) {
83440       {
83441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83442       };
83443     } catch (...) {
83444       {
83445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83446       };
83447     }
83448   }
83449
83450 }
83451
83452
83453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
83454   void * jresult ;
83455   Dali::BaseHandle arg1 ;
83456   Dali::BaseHandle *argp1 ;
83457   Dali::Toolkit::ProgressBar result;
83458
83459   argp1 = (Dali::BaseHandle *)jarg1;
83460   if (!argp1) {
83461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83462     return 0;
83463   }
83464   arg1 = *argp1;
83465   {
83466     try {
83467       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
83468     } catch (std::out_of_range& e) {
83469       {
83470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83471       };
83472     } catch (std::exception& e) {
83473       {
83474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83475       };
83476     } catch (Dali::DaliException e) {
83477       {
83478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83479       };
83480     } catch (...) {
83481       {
83482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83483       };
83484     }
83485   }
83486
83487   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83488   return jresult;
83489 }
83490
83491
83492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
83493   void * jresult ;
83494   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83495   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
83496
83497   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83498   {
83499     try {
83500       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
83501     } catch (std::out_of_range& e) {
83502       {
83503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83504       };
83505     } catch (std::exception& e) {
83506       {
83507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83508       };
83509     } catch (Dali::DaliException e) {
83510       {
83511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83512       };
83513     } catch (...) {
83514       {
83515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83516       };
83517     }
83518   }
83519
83520   jresult = (void *)result;
83521   return jresult;
83522 }
83523
83524
83525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
83526   void * jresult ;
83527   Dali::Toolkit::GaussianBlurView *result = 0 ;
83528
83529   {
83530     try {
83531       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
83532     } catch (std::out_of_range& e) {
83533       {
83534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83535       };
83536     } catch (std::exception& e) {
83537       {
83538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83539       };
83540     } catch (Dali::DaliException e) {
83541       {
83542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83543       };
83544     } catch (...) {
83545       {
83546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83547       };
83548     }
83549   }
83550
83551   jresult = (void *)result;
83552   return jresult;
83553 }
83554
83555
83556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
83557   void * jresult ;
83558   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
83559   Dali::Toolkit::GaussianBlurView *result = 0 ;
83560
83561   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83562   if (!arg1) {
83563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83564     return 0;
83565   }
83566   {
83567     try {
83568       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
83569     } catch (std::out_of_range& e) {
83570       {
83571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83572       };
83573     } catch (std::exception& e) {
83574       {
83575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83576       };
83577     } catch (Dali::DaliException e) {
83578       {
83579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83580       };
83581     } catch (...) {
83582       {
83583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83584       };
83585     }
83586   }
83587
83588   jresult = (void *)result;
83589   return jresult;
83590 }
83591
83592
83593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
83594   void * jresult ;
83595   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83596   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
83597   Dali::Toolkit::GaussianBlurView *result = 0 ;
83598
83599   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83600   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83601   if (!arg2) {
83602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83603     return 0;
83604   }
83605   {
83606     try {
83607       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
83608     } catch (std::out_of_range& e) {
83609       {
83610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83611       };
83612     } catch (std::exception& e) {
83613       {
83614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83615       };
83616     } catch (Dali::DaliException e) {
83617       {
83618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83619       };
83620     } catch (...) {
83621       {
83622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83623       };
83624     }
83625   }
83626
83627   jresult = (void *)result;
83628   return jresult;
83629 }
83630
83631
83632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
83633   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83634
83635   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83636   {
83637     try {
83638       delete arg1;
83639     } catch (std::out_of_range& e) {
83640       {
83641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83642       };
83643     } catch (std::exception& e) {
83644       {
83645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83646       };
83647     } catch (Dali::DaliException e) {
83648       {
83649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83650       };
83651     } catch (...) {
83652       {
83653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83654       };
83655     }
83656   }
83657
83658 }
83659
83660
83661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
83662   void * jresult ;
83663   Dali::BaseHandle arg1 ;
83664   Dali::BaseHandle *argp1 ;
83665   Dali::Toolkit::GaussianBlurView result;
83666
83667   argp1 = (Dali::BaseHandle *)jarg1;
83668   if (!argp1) {
83669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83670     return 0;
83671   }
83672   arg1 = *argp1;
83673   {
83674     try {
83675       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
83676     } catch (std::out_of_range& e) {
83677       {
83678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83679       };
83680     } catch (std::exception& e) {
83681       {
83682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83683       };
83684     } catch (Dali::DaliException e) {
83685       {
83686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83687       };
83688     } catch (...) {
83689       {
83690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83691       };
83692     }
83693   }
83694
83695   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83696   return jresult;
83697 }
83698
83699
83700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
83701   void * jresult ;
83702   Dali::Toolkit::GaussianBlurView result;
83703
83704   {
83705     try {
83706       result = Dali::Toolkit::GaussianBlurView::New();
83707     } catch (std::out_of_range& e) {
83708       {
83709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83710       };
83711     } catch (std::exception& e) {
83712       {
83713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83714       };
83715     } catch (Dali::DaliException e) {
83716       {
83717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83718       };
83719     } catch (...) {
83720       {
83721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83722       };
83723     }
83724   }
83725
83726   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83727   return jresult;
83728 }
83729
83730
83731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
83732   void * jresult ;
83733   unsigned int arg1 ;
83734   float arg2 ;
83735   Dali::Pixel::Format arg3 ;
83736   float arg4 ;
83737   float arg5 ;
83738   bool arg6 ;
83739   Dali::Toolkit::GaussianBlurView result;
83740
83741   arg1 = (unsigned int)jarg1;
83742   arg2 = (float)jarg2;
83743   arg3 = (Dali::Pixel::Format)jarg3;
83744   arg4 = (float)jarg4;
83745   arg5 = (float)jarg5;
83746   arg6 = jarg6 ? true : false;
83747   {
83748     try {
83749       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
83750     } catch (std::out_of_range& e) {
83751       {
83752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83753       };
83754     } catch (std::exception& e) {
83755       {
83756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83757       };
83758     } catch (Dali::DaliException e) {
83759       {
83760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83761       };
83762     } catch (...) {
83763       {
83764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83765       };
83766     }
83767   }
83768
83769   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83770   return jresult;
83771 }
83772
83773
83774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
83775   void * jresult ;
83776   unsigned int arg1 ;
83777   float arg2 ;
83778   Dali::Pixel::Format arg3 ;
83779   float arg4 ;
83780   float arg5 ;
83781   Dali::Toolkit::GaussianBlurView result;
83782
83783   arg1 = (unsigned int)jarg1;
83784   arg2 = (float)jarg2;
83785   arg3 = (Dali::Pixel::Format)jarg3;
83786   arg4 = (float)jarg4;
83787   arg5 = (float)jarg5;
83788   {
83789     try {
83790       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
83791     } catch (std::out_of_range& e) {
83792       {
83793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83794       };
83795     } catch (std::exception& e) {
83796       {
83797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83798       };
83799     } catch (Dali::DaliException e) {
83800       {
83801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83802       };
83803     } catch (...) {
83804       {
83805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83806       };
83807     }
83808   }
83809
83810   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83811   return jresult;
83812 }
83813
83814
83815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
83816   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83817   Dali::Actor arg2 ;
83818   Dali::Actor *argp2 ;
83819
83820   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83821   argp2 = (Dali::Actor *)jarg2;
83822   if (!argp2) {
83823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83824     return ;
83825   }
83826   arg2 = *argp2;
83827   {
83828     try {
83829       (arg1)->Add(arg2);
83830     } catch (std::out_of_range& e) {
83831       {
83832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83833       };
83834     } catch (std::exception& e) {
83835       {
83836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83837       };
83838     } catch (Dali::DaliException e) {
83839       {
83840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83841       };
83842     } catch (...) {
83843       {
83844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83845       };
83846     }
83847   }
83848
83849 }
83850
83851
83852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
83853   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83854   Dali::Actor arg2 ;
83855   Dali::Actor *argp2 ;
83856
83857   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83858   argp2 = (Dali::Actor *)jarg2;
83859   if (!argp2) {
83860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83861     return ;
83862   }
83863   arg2 = *argp2;
83864   {
83865     try {
83866       (arg1)->Remove(arg2);
83867     } catch (std::out_of_range& e) {
83868       {
83869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83870       };
83871     } catch (std::exception& e) {
83872       {
83873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83874       };
83875     } catch (Dali::DaliException e) {
83876       {
83877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83878       };
83879     } catch (...) {
83880       {
83881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83882       };
83883     }
83884   }
83885
83886 }
83887
83888
83889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
83890   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83891
83892   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83893   {
83894     try {
83895       (arg1)->Activate();
83896     } catch (std::out_of_range& e) {
83897       {
83898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83899       };
83900     } catch (std::exception& e) {
83901       {
83902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83903       };
83904     } catch (Dali::DaliException e) {
83905       {
83906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83907       };
83908     } catch (...) {
83909       {
83910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83911       };
83912     }
83913   }
83914
83915 }
83916
83917
83918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
83919   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83920
83921   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83922   {
83923     try {
83924       (arg1)->ActivateOnce();
83925     } catch (std::out_of_range& e) {
83926       {
83927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83928       };
83929     } catch (std::exception& e) {
83930       {
83931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83932       };
83933     } catch (Dali::DaliException e) {
83934       {
83935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83936       };
83937     } catch (...) {
83938       {
83939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83940       };
83941     }
83942   }
83943
83944 }
83945
83946
83947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
83948   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83949
83950   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83951   {
83952     try {
83953       (arg1)->Deactivate();
83954     } catch (std::out_of_range& e) {
83955       {
83956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83957       };
83958     } catch (std::exception& e) {
83959       {
83960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83961       };
83962     } catch (Dali::DaliException e) {
83963       {
83964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83965       };
83966     } catch (...) {
83967       {
83968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83969       };
83970     }
83971   }
83972
83973 }
83974
83975
83976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
83977   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83978   Dali::Texture arg2 ;
83979   Dali::FrameBuffer arg3 ;
83980   Dali::Texture *argp2 ;
83981   Dali::FrameBuffer *argp3 ;
83982
83983   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83984   argp2 = (Dali::Texture *)jarg2;
83985   if (!argp2) {
83986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
83987     return ;
83988   }
83989   arg2 = *argp2;
83990   argp3 = (Dali::FrameBuffer *)jarg3;
83991   if (!argp3) {
83992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
83993     return ;
83994   }
83995   arg3 = *argp3;
83996   {
83997     try {
83998       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
83999     } catch (std::out_of_range& e) {
84000       {
84001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84002       };
84003     } catch (std::exception& e) {
84004       {
84005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84006       };
84007     } catch (Dali::DaliException e) {
84008       {
84009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84010       };
84011     } catch (...) {
84012       {
84013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84014       };
84015     }
84016   }
84017
84018 }
84019
84020
84021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
84022   int jresult ;
84023   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84024   Dali::Property::Index result;
84025
84026   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84027   {
84028     try {
84029       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
84030     } catch (std::out_of_range& e) {
84031       {
84032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84033       };
84034     } catch (std::exception& e) {
84035       {
84036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84037       };
84038     } catch (Dali::DaliException e) {
84039       {
84040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84041       };
84042     } catch (...) {
84043       {
84044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84045       };
84046     }
84047   }
84048
84049   jresult = result;
84050   return jresult;
84051 }
84052
84053
84054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
84055   void * jresult ;
84056   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84057   Dali::FrameBuffer result;
84058
84059   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84060   {
84061     try {
84062       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
84063     } catch (std::out_of_range& e) {
84064       {
84065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84066       };
84067     } catch (std::exception& e) {
84068       {
84069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84070       };
84071     } catch (Dali::DaliException e) {
84072       {
84073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84074       };
84075     } catch (...) {
84076       {
84077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84078       };
84079     }
84080   }
84081
84082   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
84083   return jresult;
84084 }
84085
84086
84087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
84088   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84089   Dali::Vector4 *arg2 = 0 ;
84090
84091   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84092   arg2 = (Dali::Vector4 *)jarg2;
84093   if (!arg2) {
84094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
84095     return ;
84096   }
84097   {
84098     try {
84099       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
84100     } catch (std::out_of_range& e) {
84101       {
84102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84103       };
84104     } catch (std::exception& e) {
84105       {
84106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84107       };
84108     } catch (Dali::DaliException e) {
84109       {
84110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84111       };
84112     } catch (...) {
84113       {
84114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84115       };
84116     }
84117   }
84118
84119 }
84120
84121
84122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
84123   void * jresult ;
84124   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84125   Dali::Vector4 result;
84126
84127   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84128   {
84129     try {
84130       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
84131     } catch (std::out_of_range& e) {
84132       {
84133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84134       };
84135     } catch (std::exception& e) {
84136       {
84137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84138       };
84139     } catch (Dali::DaliException e) {
84140       {
84141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84142       };
84143     } catch (...) {
84144       {
84145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84146       };
84147     }
84148   }
84149
84150   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
84151   return jresult;
84152 }
84153
84154
84155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
84156   void * jresult ;
84157   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84158   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
84159
84160   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84161   {
84162     try {
84163       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
84164     } catch (std::out_of_range& e) {
84165       {
84166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84167       };
84168     } catch (std::exception& e) {
84169       {
84170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84171       };
84172     } catch (Dali::DaliException e) {
84173       {
84174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84175       };
84176     } catch (...) {
84177       {
84178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84179       };
84180     }
84181   }
84182
84183   jresult = (void *)result;
84184   return jresult;
84185 }
84186
84187
84188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
84189   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84190
84191   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84192   {
84193     try {
84194       delete arg1;
84195     } catch (std::out_of_range& e) {
84196       {
84197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84198       };
84199     } catch (std::exception& e) {
84200       {
84201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84202       };
84203     } catch (Dali::DaliException e) {
84204       {
84205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84206       };
84207     } catch (...) {
84208       {
84209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84210       };
84211     }
84212   }
84213
84214 }
84215
84216
84217 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
84218   unsigned int jresult ;
84219   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84220   unsigned int result;
84221
84222   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84223   {
84224     try {
84225       result = (unsigned int)(arg1)->GetNumberOfPages();
84226     } catch (std::out_of_range& e) {
84227       {
84228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84229       };
84230     } catch (std::exception& e) {
84231       {
84232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84233       };
84234     } catch (Dali::DaliException e) {
84235       {
84236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84237       };
84238     } catch (...) {
84239       {
84240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84241       };
84242     }
84243   }
84244
84245   jresult = result;
84246   return jresult;
84247 }
84248
84249
84250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
84251   void * jresult ;
84252   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84253   unsigned int arg2 ;
84254   Dali::Texture result;
84255
84256   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84257   arg2 = (unsigned int)jarg2;
84258   {
84259     try {
84260       result = (arg1)->NewPage(arg2);
84261     } catch (std::out_of_range& e) {
84262       {
84263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84264       };
84265     } catch (std::exception& e) {
84266       {
84267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84268       };
84269     } catch (Dali::DaliException e) {
84270       {
84271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84272       };
84273     } catch (...) {
84274       {
84275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84276       };
84277     }
84278   }
84279
84280   jresult = new Dali::Texture((const Dali::Texture &)result);
84281   return jresult;
84282 }
84283
84284
84285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
84286   int jresult ;
84287   int result;
84288
84289   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
84290   jresult = (int)result;
84291   return jresult;
84292 }
84293
84294
84295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
84296   int jresult ;
84297   int result;
84298
84299   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
84300   jresult = (int)result;
84301   return jresult;
84302 }
84303
84304
84305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
84306   int jresult ;
84307   int result;
84308
84309   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
84310   jresult = (int)result;
84311   return jresult;
84312 }
84313
84314
84315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
84316   void * jresult ;
84317   Dali::Toolkit::PageTurnView::Property *result = 0 ;
84318
84319   {
84320     try {
84321       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
84322     } catch (std::out_of_range& e) {
84323       {
84324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84325       };
84326     } catch (std::exception& e) {
84327       {
84328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84329       };
84330     } catch (Dali::DaliException e) {
84331       {
84332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84333       };
84334     } catch (...) {
84335       {
84336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84337       };
84338     }
84339   }
84340
84341   jresult = (void *)result;
84342   return jresult;
84343 }
84344
84345
84346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
84347   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
84348
84349   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
84350   {
84351     try {
84352       delete arg1;
84353     } catch (std::out_of_range& e) {
84354       {
84355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84356       };
84357     } catch (std::exception& e) {
84358       {
84359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84360       };
84361     } catch (Dali::DaliException e) {
84362       {
84363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84364       };
84365     } catch (...) {
84366       {
84367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84368       };
84369     }
84370   }
84371
84372 }
84373
84374
84375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
84376   void * jresult ;
84377   Dali::Toolkit::PageTurnView *result = 0 ;
84378
84379   {
84380     try {
84381       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
84382     } catch (std::out_of_range& e) {
84383       {
84384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84385       };
84386     } catch (std::exception& e) {
84387       {
84388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84389       };
84390     } catch (Dali::DaliException e) {
84391       {
84392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84393       };
84394     } catch (...) {
84395       {
84396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84397       };
84398     }
84399   }
84400
84401   jresult = (void *)result;
84402   return jresult;
84403 }
84404
84405
84406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
84407   void * jresult ;
84408   Dali::Toolkit::PageTurnView *arg1 = 0 ;
84409   Dali::Toolkit::PageTurnView *result = 0 ;
84410
84411   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84412   if (!arg1) {
84413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84414     return 0;
84415   }
84416   {
84417     try {
84418       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
84419     } catch (std::out_of_range& e) {
84420       {
84421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84422       };
84423     } catch (std::exception& e) {
84424       {
84425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84426       };
84427     } catch (Dali::DaliException e) {
84428       {
84429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84430       };
84431     } catch (...) {
84432       {
84433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84434       };
84435     }
84436   }
84437
84438   jresult = (void *)result;
84439   return jresult;
84440 }
84441
84442
84443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
84444   void * jresult ;
84445   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84446   Dali::Toolkit::PageTurnView *arg2 = 0 ;
84447   Dali::Toolkit::PageTurnView *result = 0 ;
84448
84449   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84450   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
84451   if (!arg2) {
84452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84453     return 0;
84454   }
84455   {
84456     try {
84457       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
84458     } catch (std::out_of_range& e) {
84459       {
84460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84461       };
84462     } catch (std::exception& e) {
84463       {
84464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84465       };
84466     } catch (Dali::DaliException e) {
84467       {
84468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84469       };
84470     } catch (...) {
84471       {
84472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84473       };
84474     }
84475   }
84476
84477   jresult = (void *)result;
84478   return jresult;
84479 }
84480
84481
84482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
84483   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84484
84485   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84486   {
84487     try {
84488       delete arg1;
84489     } catch (std::out_of_range& e) {
84490       {
84491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84492       };
84493     } catch (std::exception& e) {
84494       {
84495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84496       };
84497     } catch (Dali::DaliException e) {
84498       {
84499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84500       };
84501     } catch (...) {
84502       {
84503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84504       };
84505     }
84506   }
84507
84508 }
84509
84510
84511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
84512   void * jresult ;
84513   Dali::BaseHandle arg1 ;
84514   Dali::BaseHandle *argp1 ;
84515   Dali::Toolkit::PageTurnView result;
84516
84517   argp1 = (Dali::BaseHandle *)jarg1;
84518   if (!argp1) {
84519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84520     return 0;
84521   }
84522   arg1 = *argp1;
84523   {
84524     try {
84525       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
84526     } catch (std::out_of_range& e) {
84527       {
84528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84529       };
84530     } catch (std::exception& e) {
84531       {
84532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84533       };
84534     } catch (Dali::DaliException e) {
84535       {
84536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84537       };
84538     } catch (...) {
84539       {
84540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84541       };
84542     }
84543   }
84544
84545   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
84546   return jresult;
84547 }
84548
84549
84550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
84551   void * jresult ;
84552   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84553   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84554
84555   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84556   {
84557     try {
84558       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
84559     } catch (std::out_of_range& e) {
84560       {
84561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84562       };
84563     } catch (std::exception& e) {
84564       {
84565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84566       };
84567     } catch (Dali::DaliException e) {
84568       {
84569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84570       };
84571     } catch (...) {
84572       {
84573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84574       };
84575     }
84576   }
84577
84578   jresult = (void *)result;
84579   return jresult;
84580 }
84581
84582
84583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
84584   void * jresult ;
84585   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84586   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84587
84588   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84589   {
84590     try {
84591       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
84592     } catch (std::out_of_range& e) {
84593       {
84594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84595       };
84596     } catch (std::exception& e) {
84597       {
84598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84599       };
84600     } catch (Dali::DaliException e) {
84601       {
84602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84603       };
84604     } catch (...) {
84605       {
84606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84607       };
84608     }
84609   }
84610
84611   jresult = (void *)result;
84612   return jresult;
84613 }
84614
84615
84616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
84617   void * jresult ;
84618   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84619   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84620
84621   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84622   {
84623     try {
84624       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
84625     } catch (std::out_of_range& e) {
84626       {
84627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84628       };
84629     } catch (std::exception& e) {
84630       {
84631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84632       };
84633     } catch (Dali::DaliException e) {
84634       {
84635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84636       };
84637     } catch (...) {
84638       {
84639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84640       };
84641     }
84642   }
84643
84644   jresult = (void *)result;
84645   return jresult;
84646 }
84647
84648
84649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
84650   void * jresult ;
84651   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84652   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84653
84654   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84655   {
84656     try {
84657       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
84658     } catch (std::out_of_range& e) {
84659       {
84660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84661       };
84662     } catch (std::exception& e) {
84663       {
84664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84665       };
84666     } catch (Dali::DaliException e) {
84667       {
84668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84669       };
84670     } catch (...) {
84671       {
84672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84673       };
84674     }
84675   }
84676
84677   jresult = (void *)result;
84678   return jresult;
84679 }
84680
84681
84682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
84683   void * jresult ;
84684   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84685
84686   {
84687     try {
84688       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
84689     } catch (std::out_of_range& e) {
84690       {
84691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84692       };
84693     } catch (std::exception& e) {
84694       {
84695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84696       };
84697     } catch (Dali::DaliException e) {
84698       {
84699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84700       };
84701     } catch (...) {
84702       {
84703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84704       };
84705     }
84706   }
84707
84708   jresult = (void *)result;
84709   return jresult;
84710 }
84711
84712
84713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
84714   void * jresult ;
84715   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
84716   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84717
84718   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84719   if (!arg1) {
84720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84721     return 0;
84722   }
84723   {
84724     try {
84725       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
84726     } catch (std::out_of_range& e) {
84727       {
84728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84729       };
84730     } catch (std::exception& e) {
84731       {
84732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84733       };
84734     } catch (Dali::DaliException e) {
84735       {
84736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84737       };
84738     } catch (...) {
84739       {
84740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84741       };
84742     }
84743   }
84744
84745   jresult = (void *)result;
84746   return jresult;
84747 }
84748
84749
84750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
84751   void * jresult ;
84752   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84753   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
84754   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84755
84756   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84757   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
84758   if (!arg2) {
84759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84760     return 0;
84761   }
84762   {
84763     try {
84764       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
84765     } catch (std::out_of_range& e) {
84766       {
84767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84768       };
84769     } catch (std::exception& e) {
84770       {
84771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84772       };
84773     } catch (Dali::DaliException e) {
84774       {
84775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84776       };
84777     } catch (...) {
84778       {
84779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84780       };
84781     }
84782   }
84783
84784   jresult = (void *)result;
84785   return jresult;
84786 }
84787
84788
84789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
84790   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84791
84792   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84793   {
84794     try {
84795       delete arg1;
84796     } catch (std::out_of_range& e) {
84797       {
84798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84799       };
84800     } catch (std::exception& e) {
84801       {
84802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84803       };
84804     } catch (Dali::DaliException e) {
84805       {
84806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84807       };
84808     } catch (...) {
84809       {
84810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84811       };
84812     }
84813   }
84814
84815 }
84816
84817
84818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
84819   void * jresult ;
84820   Dali::Toolkit::PageFactory *arg1 = 0 ;
84821   Dali::Vector2 *arg2 = 0 ;
84822   Dali::Toolkit::PageTurnLandscapeView result;
84823
84824   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84825   if (!arg1) {
84826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84827     return 0;
84828   }
84829   arg2 = (Dali::Vector2 *)jarg2;
84830   if (!arg2) {
84831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84832     return 0;
84833   }
84834   {
84835     try {
84836       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
84837     } catch (std::out_of_range& e) {
84838       {
84839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84840       };
84841     } catch (std::exception& e) {
84842       {
84843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84844       };
84845     } catch (Dali::DaliException e) {
84846       {
84847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84848       };
84849     } catch (...) {
84850       {
84851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84852       };
84853     }
84854   }
84855
84856   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84857   return jresult;
84858 }
84859
84860
84861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
84862   void * jresult ;
84863   Dali::BaseHandle arg1 ;
84864   Dali::BaseHandle *argp1 ;
84865   Dali::Toolkit::PageTurnLandscapeView result;
84866
84867   argp1 = (Dali::BaseHandle *)jarg1;
84868   if (!argp1) {
84869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84870     return 0;
84871   }
84872   arg1 = *argp1;
84873   {
84874     try {
84875       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
84876     } catch (std::out_of_range& e) {
84877       {
84878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84879       };
84880     } catch (std::exception& e) {
84881       {
84882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84883       };
84884     } catch (Dali::DaliException e) {
84885       {
84886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84887       };
84888     } catch (...) {
84889       {
84890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84891       };
84892     }
84893   }
84894
84895   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84896   return jresult;
84897 }
84898
84899
84900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
84901   void * jresult ;
84902   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84903
84904   {
84905     try {
84906       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
84907     } catch (std::out_of_range& e) {
84908       {
84909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84910       };
84911     } catch (std::exception& e) {
84912       {
84913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84914       };
84915     } catch (Dali::DaliException e) {
84916       {
84917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84918       };
84919     } catch (...) {
84920       {
84921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84922       };
84923     }
84924   }
84925
84926   jresult = (void *)result;
84927   return jresult;
84928 }
84929
84930
84931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
84932   void * jresult ;
84933   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
84934   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84935
84936   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84937   if (!arg1) {
84938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
84939     return 0;
84940   }
84941   {
84942     try {
84943       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
84944     } catch (std::out_of_range& e) {
84945       {
84946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84947       };
84948     } catch (std::exception& e) {
84949       {
84950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84951       };
84952     } catch (Dali::DaliException e) {
84953       {
84954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84955       };
84956     } catch (...) {
84957       {
84958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84959       };
84960     }
84961   }
84962
84963   jresult = (void *)result;
84964   return jresult;
84965 }
84966
84967
84968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
84969   void * jresult ;
84970   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
84971   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
84972   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84973
84974   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84975   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
84976   if (!arg2) {
84977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
84978     return 0;
84979   }
84980   {
84981     try {
84982       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
84983     } catch (std::out_of_range& e) {
84984       {
84985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84986       };
84987     } catch (std::exception& e) {
84988       {
84989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84990       };
84991     } catch (Dali::DaliException e) {
84992       {
84993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84994       };
84995     } catch (...) {
84996       {
84997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84998       };
84999     }
85000   }
85001
85002   jresult = (void *)result;
85003   return jresult;
85004 }
85005
85006
85007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
85008   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85009
85010   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85011   {
85012     try {
85013       delete arg1;
85014     } catch (std::out_of_range& e) {
85015       {
85016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85017       };
85018     } catch (std::exception& e) {
85019       {
85020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85021       };
85022     } catch (Dali::DaliException e) {
85023       {
85024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85025       };
85026     } catch (...) {
85027       {
85028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85029       };
85030     }
85031   }
85032
85033 }
85034
85035
85036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
85037   void * jresult ;
85038   Dali::Toolkit::PageFactory *arg1 = 0 ;
85039   Dali::Vector2 *arg2 = 0 ;
85040   Dali::Toolkit::PageTurnPortraitView result;
85041
85042   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85043   if (!arg1) {
85044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85045     return 0;
85046   }
85047   arg2 = (Dali::Vector2 *)jarg2;
85048   if (!arg2) {
85049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85050     return 0;
85051   }
85052   {
85053     try {
85054       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
85055     } catch (std::out_of_range& e) {
85056       {
85057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85058       };
85059     } catch (std::exception& e) {
85060       {
85061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85062       };
85063     } catch (Dali::DaliException e) {
85064       {
85065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85066       };
85067     } catch (...) {
85068       {
85069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85070       };
85071     }
85072   }
85073
85074   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85075   return jresult;
85076 }
85077
85078
85079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
85080   void * jresult ;
85081   Dali::BaseHandle arg1 ;
85082   Dali::BaseHandle *argp1 ;
85083   Dali::Toolkit::PageTurnPortraitView result;
85084
85085   argp1 = (Dali::BaseHandle *)jarg1;
85086   if (!argp1) {
85087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85088     return 0;
85089   }
85090   arg1 = *argp1;
85091   {
85092     try {
85093       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
85094     } catch (std::out_of_range& e) {
85095       {
85096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85097       };
85098     } catch (std::exception& e) {
85099       {
85100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85101       };
85102     } catch (Dali::DaliException e) {
85103       {
85104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85105       };
85106     } catch (...) {
85107       {
85108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85109       };
85110     }
85111   }
85112
85113   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85114   return jresult;
85115 }
85116
85117
85118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
85119   int jresult ;
85120   int result;
85121
85122   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
85123   jresult = (int)result;
85124   return jresult;
85125 }
85126
85127
85128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
85129   int jresult ;
85130   int result;
85131
85132   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
85133   jresult = (int)result;
85134   return jresult;
85135 }
85136
85137
85138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
85139   int jresult ;
85140   int result;
85141
85142   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
85143   jresult = (int)result;
85144   return jresult;
85145 }
85146
85147
85148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
85149   void * jresult ;
85150   Dali::Toolkit::ToggleButton::Property *result = 0 ;
85151
85152   {
85153     try {
85154       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
85155     } catch (std::out_of_range& e) {
85156       {
85157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85158       };
85159     } catch (std::exception& e) {
85160       {
85161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85162       };
85163     } catch (Dali::DaliException e) {
85164       {
85165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85166       };
85167     } catch (...) {
85168       {
85169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85170       };
85171     }
85172   }
85173
85174   jresult = (void *)result;
85175   return jresult;
85176 }
85177
85178
85179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
85180   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
85181
85182   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
85183   {
85184     try {
85185       delete arg1;
85186     } catch (std::out_of_range& e) {
85187       {
85188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85189       };
85190     } catch (std::exception& e) {
85191       {
85192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85193       };
85194     } catch (Dali::DaliException e) {
85195       {
85196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85197       };
85198     } catch (...) {
85199       {
85200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85201       };
85202     }
85203   }
85204
85205 }
85206
85207
85208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
85209   void * jresult ;
85210   Dali::Toolkit::ToggleButton *result = 0 ;
85211
85212   {
85213     try {
85214       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
85215     } catch (std::out_of_range& e) {
85216       {
85217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85218       };
85219     } catch (std::exception& e) {
85220       {
85221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85222       };
85223     } catch (Dali::DaliException e) {
85224       {
85225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85226       };
85227     } catch (...) {
85228       {
85229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85230       };
85231     }
85232   }
85233
85234   jresult = (void *)result;
85235   return jresult;
85236 }
85237
85238
85239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
85240   void * jresult ;
85241   Dali::Toolkit::ToggleButton *arg1 = 0 ;
85242   Dali::Toolkit::ToggleButton *result = 0 ;
85243
85244   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85245   if (!arg1) {
85246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85247     return 0;
85248   }
85249   {
85250     try {
85251       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
85252     } catch (std::out_of_range& e) {
85253       {
85254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85255       };
85256     } catch (std::exception& e) {
85257       {
85258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85259       };
85260     } catch (Dali::DaliException e) {
85261       {
85262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85263       };
85264     } catch (...) {
85265       {
85266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85267       };
85268     }
85269   }
85270
85271   jresult = (void *)result;
85272   return jresult;
85273 }
85274
85275
85276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
85277   void * jresult ;
85278   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85279   Dali::Toolkit::ToggleButton *arg2 = 0 ;
85280   Dali::Toolkit::ToggleButton *result = 0 ;
85281
85282   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85283   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
85284   if (!arg2) {
85285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85286     return 0;
85287   }
85288   {
85289     try {
85290       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
85291     } catch (std::out_of_range& e) {
85292       {
85293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85294       };
85295     } catch (std::exception& e) {
85296       {
85297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85298       };
85299     } catch (Dali::DaliException e) {
85300       {
85301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85302       };
85303     } catch (...) {
85304       {
85305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85306       };
85307     }
85308   }
85309
85310   jresult = (void *)result;
85311   return jresult;
85312 }
85313
85314
85315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
85316   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85317
85318   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85319   {
85320     try {
85321       delete arg1;
85322     } catch (std::out_of_range& e) {
85323       {
85324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85325       };
85326     } catch (std::exception& e) {
85327       {
85328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85329       };
85330     } catch (Dali::DaliException e) {
85331       {
85332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85333       };
85334     } catch (...) {
85335       {
85336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85337       };
85338     }
85339   }
85340
85341 }
85342
85343
85344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
85345   void * jresult ;
85346   Dali::Toolkit::ToggleButton result;
85347
85348   {
85349     try {
85350       result = Dali::Toolkit::ToggleButton::New();
85351     } catch (std::out_of_range& e) {
85352       {
85353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85354       };
85355     } catch (std::exception& e) {
85356       {
85357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85358       };
85359     } catch (Dali::DaliException e) {
85360       {
85361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85362       };
85363     } catch (...) {
85364       {
85365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85366       };
85367     }
85368   }
85369
85370   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85371   return jresult;
85372 }
85373
85374
85375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
85376   void * jresult ;
85377   Dali::BaseHandle arg1 ;
85378   Dali::BaseHandle *argp1 ;
85379   Dali::Toolkit::ToggleButton result;
85380
85381   argp1 = (Dali::BaseHandle *)jarg1;
85382   if (!argp1) {
85383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85384     return 0;
85385   }
85386   arg1 = *argp1;
85387   {
85388     try {
85389       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
85390     } catch (std::out_of_range& e) {
85391       {
85392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85393       };
85394     } catch (std::exception& e) {
85395       {
85396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85397       };
85398     } catch (Dali::DaliException e) {
85399       {
85400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85401       };
85402     } catch (...) {
85403       {
85404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85405       };
85406     }
85407   }
85408
85409   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85410   return jresult;
85411 }
85412
85413
85414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
85415   void * jresult ;
85416   Dali::Toolkit::Visual::Base *result = 0 ;
85417
85418   {
85419     try {
85420       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
85421     } catch (std::out_of_range& e) {
85422       {
85423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85424       };
85425     } catch (std::exception& e) {
85426       {
85427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85428       };
85429     } catch (Dali::DaliException e) {
85430       {
85431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85432       };
85433     } catch (...) {
85434       {
85435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85436       };
85437     }
85438   }
85439
85440   jresult = (void *)result;
85441   return jresult;
85442 }
85443
85444
85445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
85446   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85447
85448   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85449   {
85450     try {
85451       delete arg1;
85452     } catch (std::out_of_range& e) {
85453       {
85454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85455       };
85456     } catch (std::exception& e) {
85457       {
85458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85459       };
85460     } catch (Dali::DaliException e) {
85461       {
85462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85463       };
85464     } catch (...) {
85465       {
85466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85467       };
85468     }
85469   }
85470
85471 }
85472
85473
85474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
85475   void * jresult ;
85476   Dali::Toolkit::Visual::Base *arg1 = 0 ;
85477   Dali::Toolkit::Visual::Base *result = 0 ;
85478
85479   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85480   if (!arg1) {
85481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85482     return 0;
85483   }
85484   {
85485     try {
85486       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
85487     } catch (std::out_of_range& e) {
85488       {
85489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85490       };
85491     } catch (std::exception& e) {
85492       {
85493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85494       };
85495     } catch (Dali::DaliException e) {
85496       {
85497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85498       };
85499     } catch (...) {
85500       {
85501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85502       };
85503     }
85504   }
85505
85506   jresult = (void *)result;
85507   return jresult;
85508 }
85509
85510
85511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
85512   void * jresult ;
85513   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85514   Dali::Toolkit::Visual::Base *arg2 = 0 ;
85515   Dali::Toolkit::Visual::Base *result = 0 ;
85516
85517   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85518   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
85519   if (!arg2) {
85520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85521     return 0;
85522   }
85523   {
85524     try {
85525       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
85526     } catch (std::out_of_range& e) {
85527       {
85528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85529       };
85530     } catch (std::exception& e) {
85531       {
85532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85533       };
85534     } catch (Dali::DaliException e) {
85535       {
85536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85537       };
85538     } catch (...) {
85539       {
85540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85541       };
85542     }
85543   }
85544
85545   jresult = (void *)result;
85546   return jresult;
85547 }
85548
85549
85550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
85551   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85552   std::string *arg2 = 0 ;
85553
85554   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85555   if (!jarg2) {
85556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85557     return ;
85558   }
85559   std::string arg2_str(jarg2);
85560   arg2 = &arg2_str;
85561   {
85562     try {
85563       (arg1)->SetName((std::string const &)*arg2);
85564     } catch (std::out_of_range& e) {
85565       {
85566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85567       };
85568     } catch (std::exception& e) {
85569       {
85570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85571       };
85572     } catch (Dali::DaliException e) {
85573       {
85574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85575       };
85576     } catch (...) {
85577       {
85578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85579       };
85580     }
85581   }
85582
85583
85584   //argout typemap for const std::string&
85585
85586 }
85587
85588
85589 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
85590   char * jresult ;
85591   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85592   std::string *result = 0 ;
85593
85594   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85595   {
85596     try {
85597       result = (std::string *) &(arg1)->GetName();
85598     } catch (std::out_of_range& e) {
85599       {
85600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85601       };
85602     } catch (std::exception& e) {
85603       {
85604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85605       };
85606     } catch (Dali::DaliException e) {
85607       {
85608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85609       };
85610     } catch (...) {
85611       {
85612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85613       };
85614     }
85615   }
85616
85617   jresult = SWIG_csharp_string_callback(result->c_str());
85618   return jresult;
85619 }
85620
85621
85622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
85623   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85624   Dali::Property::Map *arg2 = 0 ;
85625   Dali::Size arg3 ;
85626   Dali::Size *argp3 ;
85627
85628   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85629   arg2 = (Dali::Property::Map *)jarg2;
85630   if (!arg2) {
85631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85632     return ;
85633   }
85634   argp3 = (Dali::Size *)jarg3;
85635   if (!argp3) {
85636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
85637     return ;
85638   }
85639   arg3 = *argp3;
85640   {
85641     try {
85642       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
85643     } catch (std::out_of_range& e) {
85644       {
85645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85646       };
85647     } catch (std::exception& e) {
85648       {
85649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85650       };
85651     } catch (Dali::DaliException e) {
85652       {
85653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85654       };
85655     } catch (...) {
85656       {
85657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85658       };
85659     }
85660   }
85661
85662 }
85663
85664
85665 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
85666   float jresult ;
85667   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85668   float arg2 ;
85669   float result;
85670
85671   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85672   arg2 = (float)jarg2;
85673   {
85674     try {
85675       result = (float)(arg1)->GetHeightForWidth(arg2);
85676     } catch (std::out_of_range& e) {
85677       {
85678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85679       };
85680     } catch (std::exception& e) {
85681       {
85682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85683       };
85684     } catch (Dali::DaliException e) {
85685       {
85686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85687       };
85688     } catch (...) {
85689       {
85690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85691       };
85692     }
85693   }
85694
85695   jresult = result;
85696   return jresult;
85697 }
85698
85699
85700 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
85701   float jresult ;
85702   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85703   float arg2 ;
85704   float result;
85705
85706   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85707   arg2 = (float)jarg2;
85708   {
85709     try {
85710       result = (float)(arg1)->GetWidthForHeight(arg2);
85711     } catch (std::out_of_range& e) {
85712       {
85713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85714       };
85715     } catch (std::exception& e) {
85716       {
85717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85718       };
85719     } catch (Dali::DaliException e) {
85720       {
85721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85722       };
85723     } catch (...) {
85724       {
85725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85726       };
85727     }
85728   }
85729
85730   jresult = result;
85731   return jresult;
85732 }
85733
85734
85735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
85736   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85737   Dali::Vector2 *arg2 = 0 ;
85738
85739   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85740   arg2 = (Dali::Vector2 *)jarg2;
85741   if (!arg2) {
85742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
85743     return ;
85744   }
85745   {
85746     try {
85747       (arg1)->GetNaturalSize(*arg2);
85748     } catch (std::out_of_range& e) {
85749       {
85750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85751       };
85752     } catch (std::exception& e) {
85753       {
85754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85755       };
85756     } catch (Dali::DaliException e) {
85757       {
85758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85759       };
85760     } catch (...) {
85761       {
85762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85763       };
85764     }
85765   }
85766
85767 }
85768
85769
85770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
85771   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85772   float arg2 ;
85773
85774   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85775   arg2 = (int)jarg2;
85776   {
85777     try {
85778       (arg1)->SetDepthIndex(arg2);
85779     } catch (std::out_of_range& e) {
85780       {
85781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85782       };
85783     } catch (std::exception& e) {
85784       {
85785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85786       };
85787     } catch (Dali::DaliException e) {
85788       {
85789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85790       };
85791     } catch (...) {
85792       {
85793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85794       };
85795     }
85796   }
85797
85798 }
85799
85800
85801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
85802   int jresult ;
85803   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85804   int result;
85805
85806   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85807   {
85808     try {
85809       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
85810     } catch (std::out_of_range& e) {
85811       {
85812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85813       };
85814     } catch (std::exception& e) {
85815       {
85816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85817       };
85818     } catch (Dali::DaliException e) {
85819       {
85820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85821       };
85822     } catch (...) {
85823       {
85824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85825       };
85826     }
85827   }
85828
85829   jresult = result;
85830   return jresult;
85831 }
85832
85833
85834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
85835   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85836   Dali::Property::Map *arg2 = 0 ;
85837
85838   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85839   arg2 = (Dali::Property::Map *)jarg2;
85840   if (!arg2) {
85841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
85842     return ;
85843   }
85844   {
85845     try {
85846       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
85847     } catch (std::out_of_range& e) {
85848       {
85849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85850       };
85851     } catch (std::exception& e) {
85852       {
85853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85854       };
85855     } catch (Dali::DaliException e) {
85856       {
85857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85858       };
85859     } catch (...) {
85860       {
85861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85862       };
85863     }
85864   }
85865
85866 }
85867
85868
85869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
85870   void * jresult ;
85871   Dali::Toolkit::VisualFactory result;
85872
85873   {
85874     try {
85875       result = Dali::Toolkit::VisualFactory::Get();
85876     } catch (std::out_of_range& e) {
85877       {
85878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85879       };
85880     } catch (std::exception& e) {
85881       {
85882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85883       };
85884     } catch (Dali::DaliException e) {
85885       {
85886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85887       };
85888     } catch (...) {
85889       {
85890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85891       };
85892     }
85893   }
85894
85895   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
85896   return jresult;
85897 }
85898
85899
85900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
85901   void * jresult ;
85902   Dali::Toolkit::VisualFactory *result = 0 ;
85903
85904   {
85905     try {
85906       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
85907     } catch (std::out_of_range& e) {
85908       {
85909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85910       };
85911     } catch (std::exception& e) {
85912       {
85913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85914       };
85915     } catch (Dali::DaliException e) {
85916       {
85917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85918       };
85919     } catch (...) {
85920       {
85921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85922       };
85923     }
85924   }
85925
85926   jresult = (void *)result;
85927   return jresult;
85928 }
85929
85930
85931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
85932   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85933
85934   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85935   {
85936     try {
85937       delete arg1;
85938     } catch (std::out_of_range& e) {
85939       {
85940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85941       };
85942     } catch (std::exception& e) {
85943       {
85944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85945       };
85946     } catch (Dali::DaliException e) {
85947       {
85948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85949       };
85950     } catch (...) {
85951       {
85952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85953       };
85954     }
85955   }
85956
85957 }
85958
85959
85960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
85961   void * jresult ;
85962   Dali::Toolkit::VisualFactory *arg1 = 0 ;
85963   Dali::Toolkit::VisualFactory *result = 0 ;
85964
85965   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85966   if (!arg1) {
85967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
85968     return 0;
85969   }
85970   {
85971     try {
85972       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
85973     } catch (std::out_of_range& e) {
85974       {
85975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85976       };
85977     } catch (std::exception& e) {
85978       {
85979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85980       };
85981     } catch (Dali::DaliException e) {
85982       {
85983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85984       };
85985     } catch (...) {
85986       {
85987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85988       };
85989     }
85990   }
85991
85992   jresult = (void *)result;
85993   return jresult;
85994 }
85995
85996
85997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
85998   void * jresult ;
85999   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86000   Dali::Toolkit::VisualFactory *arg2 = 0 ;
86001   Dali::Toolkit::VisualFactory *result = 0 ;
86002
86003   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86004   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
86005   if (!arg2) {
86006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86007     return 0;
86008   }
86009   {
86010     try {
86011       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
86012     } catch (std::out_of_range& e) {
86013       {
86014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86015       };
86016     } catch (std::exception& e) {
86017       {
86018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86019       };
86020     } catch (Dali::DaliException e) {
86021       {
86022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86023       };
86024     } catch (...) {
86025       {
86026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86027       };
86028     }
86029   }
86030
86031   jresult = (void *)result;
86032   return jresult;
86033 }
86034
86035
86036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
86037   void * jresult ;
86038   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86039   Dali::Property::Map *arg2 = 0 ;
86040   Dali::Toolkit::Visual::Base result;
86041
86042   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86043   arg2 = (Dali::Property::Map *)jarg2;
86044   if (!arg2) {
86045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
86046     return 0;
86047   }
86048   {
86049     try {
86050       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
86051     } catch (std::out_of_range& e) {
86052       {
86053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86054       };
86055     } catch (std::exception& e) {
86056       {
86057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86058       };
86059     } catch (Dali::DaliException e) {
86060       {
86061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86062       };
86063     } catch (...) {
86064       {
86065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86066       };
86067     }
86068   }
86069
86070   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86071   return jresult;
86072 }
86073
86074
86075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
86076   void * jresult ;
86077   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86078   std::string *arg2 = 0 ;
86079   Dali::ImageDimensions arg3 ;
86080   Dali::ImageDimensions *argp3 ;
86081   Dali::Toolkit::Visual::Base result;
86082
86083   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86084   if (!jarg2) {
86085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86086     return 0;
86087   }
86088   std::string arg2_str(jarg2);
86089   arg2 = &arg2_str;
86090   argp3 = (Dali::ImageDimensions *)jarg3;
86091   if (!argp3) {
86092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86093     return 0;
86094   }
86095   arg3 = *argp3;
86096   {
86097     try {
86098       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
86099     } catch (std::out_of_range& e) {
86100       {
86101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86102       };
86103     } catch (std::exception& e) {
86104       {
86105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86106       };
86107     } catch (Dali::DaliException e) {
86108       {
86109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86110       };
86111     } catch (...) {
86112       {
86113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86114       };
86115     }
86116   }
86117
86118   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86119
86120   //argout typemap for const std::string&
86121
86122   return jresult;
86123 }
86124
86125
86126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
86127   void * jresult ;
86128   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86129
86130   {
86131     try {
86132       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
86133     } catch (std::out_of_range& e) {
86134       {
86135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86136       };
86137     } catch (std::exception& e) {
86138       {
86139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86140       };
86141     } catch (Dali::DaliException e) {
86142       {
86143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86144       };
86145     } catch (...) {
86146       {
86147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86148       };
86149     }
86150   }
86151
86152   jresult = (void *)result;
86153   return jresult;
86154 }
86155
86156
86157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
86158   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86159
86160   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86161   {
86162     try {
86163       delete arg1;
86164     } catch (std::out_of_range& e) {
86165       {
86166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86167       };
86168     } catch (std::exception& e) {
86169       {
86170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86171       };
86172     } catch (Dali::DaliException e) {
86173       {
86174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86175       };
86176     } catch (...) {
86177       {
86178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86179       };
86180     }
86181   }
86182
86183 }
86184
86185
86186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
86187   void * jresult ;
86188   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
86189   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86190
86191   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86192   if (!arg1) {
86193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86194     return 0;
86195   }
86196   {
86197     try {
86198       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
86199     } catch (std::out_of_range& e) {
86200       {
86201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86202       };
86203     } catch (std::exception& e) {
86204       {
86205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86206       };
86207     } catch (Dali::DaliException e) {
86208       {
86209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86210       };
86211     } catch (...) {
86212       {
86213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86214       };
86215     }
86216   }
86217
86218   jresult = (void *)result;
86219   return jresult;
86220 }
86221
86222
86223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
86224   void * jresult ;
86225   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86226   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
86227   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86228
86229   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86230   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
86231   if (!arg2) {
86232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86233     return 0;
86234   }
86235   {
86236     try {
86237       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
86238     } catch (std::out_of_range& e) {
86239       {
86240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86241       };
86242     } catch (std::exception& e) {
86243       {
86244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86245       };
86246     } catch (Dali::DaliException e) {
86247       {
86248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86249       };
86250     } catch (...) {
86251       {
86252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86253       };
86254     }
86255   }
86256
86257   jresult = (void *)result;
86258   return jresult;
86259 }
86260
86261
86262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
86263   void * jresult ;
86264   Dali::Toolkit::AsyncImageLoader result;
86265
86266   {
86267     try {
86268       result = Dali::Toolkit::AsyncImageLoader::New();
86269     } catch (std::out_of_range& e) {
86270       {
86271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86272       };
86273     } catch (std::exception& e) {
86274       {
86275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86276       };
86277     } catch (Dali::DaliException e) {
86278       {
86279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86280       };
86281     } catch (...) {
86282       {
86283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86284       };
86285     }
86286   }
86287
86288   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86289   return jresult;
86290 }
86291
86292
86293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
86294   void * jresult ;
86295   Dali::BaseHandle arg1 ;
86296   Dali::BaseHandle *argp1 ;
86297   Dali::Toolkit::AsyncImageLoader result;
86298
86299   argp1 = (Dali::BaseHandle *)jarg1;
86300   if (!argp1) {
86301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86302     return 0;
86303   }
86304   arg1 = *argp1;
86305   {
86306     try {
86307       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
86308     } catch (std::out_of_range& e) {
86309       {
86310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86311       };
86312     } catch (std::exception& e) {
86313       {
86314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86315       };
86316     } catch (Dali::DaliException e) {
86317       {
86318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86319       };
86320     } catch (...) {
86321       {
86322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86323       };
86324     }
86325   }
86326
86327   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86328   return jresult;
86329 }
86330
86331
86332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
86333   unsigned int jresult ;
86334   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86335   std::string *arg2 = 0 ;
86336   uint32_t result;
86337
86338   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86339   if (!jarg2) {
86340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86341     return 0;
86342   }
86343   std::string arg2_str(jarg2);
86344   arg2 = &arg2_str;
86345   {
86346     try {
86347       result = (arg1)->Load((std::string const &)*arg2);
86348     } catch (std::out_of_range& e) {
86349       {
86350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86351       };
86352     } catch (std::exception& e) {
86353       {
86354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86355       };
86356     } catch (Dali::DaliException e) {
86357       {
86358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86359       };
86360     } catch (...) {
86361       {
86362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86363       };
86364     }
86365   }
86366
86367   jresult = result;
86368
86369   //argout typemap for const std::string&
86370
86371   return jresult;
86372 }
86373
86374
86375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
86376   unsigned int jresult ;
86377   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86378   std::string *arg2 = 0 ;
86379   Dali::ImageDimensions arg3 ;
86380   Dali::ImageDimensions *argp3 ;
86381   uint32_t result;
86382
86383   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86384   if (!jarg2) {
86385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86386     return 0;
86387   }
86388   std::string arg2_str(jarg2);
86389   arg2 = &arg2_str;
86390   argp3 = (Dali::ImageDimensions *)jarg3;
86391   if (!argp3) {
86392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86393     return 0;
86394   }
86395   arg3 = *argp3;
86396   {
86397     try {
86398       result = (arg1)->Load((std::string const &)*arg2,arg3);
86399     } catch (std::out_of_range& e) {
86400       {
86401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86402       };
86403     } catch (std::exception& e) {
86404       {
86405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86406       };
86407     } catch (Dali::DaliException e) {
86408       {
86409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86410       };
86411     } catch (...) {
86412       {
86413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86414       };
86415     }
86416   }
86417
86418   jresult = result;
86419
86420   //argout typemap for const std::string&
86421
86422   return jresult;
86423 }
86424
86425
86426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
86427   unsigned int jresult ;
86428   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86429   std::string *arg2 = 0 ;
86430   Dali::ImageDimensions arg3 ;
86431   Dali::FittingMode::Type arg4 ;
86432   Dali::SamplingMode::Type arg5 ;
86433   bool arg6 ;
86434   Dali::ImageDimensions *argp3 ;
86435   uint32_t result;
86436
86437   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86438   if (!jarg2) {
86439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86440     return 0;
86441   }
86442   std::string arg2_str(jarg2);
86443   arg2 = &arg2_str;
86444   argp3 = (Dali::ImageDimensions *)jarg3;
86445   if (!argp3) {
86446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86447     return 0;
86448   }
86449   arg3 = *argp3;
86450   arg4 = (Dali::FittingMode::Type)jarg4;
86451   arg5 = (Dali::SamplingMode::Type)jarg5;
86452   arg6 = jarg6 ? true : false;
86453   {
86454     try {
86455       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
86456     } catch (std::out_of_range& e) {
86457       {
86458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86459       };
86460     } catch (std::exception& e) {
86461       {
86462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86463       };
86464     } catch (Dali::DaliException e) {
86465       {
86466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86467       };
86468     } catch (...) {
86469       {
86470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86471       };
86472     }
86473   }
86474
86475   jresult = result;
86476
86477   //argout typemap for const std::string&
86478
86479   return jresult;
86480 }
86481
86482
86483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
86484   unsigned int jresult ;
86485   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86486   uint32_t arg2 ;
86487   bool result;
86488
86489   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86490   arg2 = (uint32_t)jarg2;
86491   {
86492     try {
86493       result = (bool)(arg1)->Cancel(arg2);
86494     } catch (std::out_of_range& e) {
86495       {
86496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86497       };
86498     } catch (std::exception& e) {
86499       {
86500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86501       };
86502     } catch (Dali::DaliException e) {
86503       {
86504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86505       };
86506     } catch (...) {
86507       {
86508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86509       };
86510     }
86511   }
86512
86513   jresult = result;
86514   return jresult;
86515 }
86516
86517
86518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
86519   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86520
86521   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86522   {
86523     try {
86524       (arg1)->CancelAll();
86525     } catch (std::out_of_range& e) {
86526       {
86527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86528       };
86529     } catch (std::exception& e) {
86530       {
86531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86532       };
86533     } catch (Dali::DaliException e) {
86534       {
86535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86536       };
86537     } catch (...) {
86538       {
86539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86540       };
86541     }
86542   }
86543
86544 }
86545
86546
86547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
86548   void * jresult ;
86549   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86550   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
86551
86552   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86553   {
86554     try {
86555       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
86556     } catch (std::out_of_range& e) {
86557       {
86558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86559       };
86560     } catch (std::exception& e) {
86561       {
86562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86563       };
86564     } catch (Dali::DaliException e) {
86565       {
86566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86567       };
86568     } catch (...) {
86569       {
86570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86571       };
86572     }
86573   }
86574
86575   jresult = (void *)result;
86576   return jresult;
86577 }
86578
86579
86580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
86581   void * jresult ;
86582   std::string *arg1 = 0 ;
86583   Dali::PixelData result;
86584
86585   if (!jarg1) {
86586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86587     return 0;
86588   }
86589   std::string arg1_str(jarg1);
86590   arg1 = &arg1_str;
86591   {
86592     try {
86593       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
86594     } catch (std::out_of_range& e) {
86595       {
86596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86597       };
86598     } catch (std::exception& e) {
86599       {
86600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86601       };
86602     } catch (Dali::DaliException e) {
86603       {
86604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86605       };
86606     } catch (...) {
86607       {
86608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86609       };
86610     }
86611   }
86612
86613   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86614
86615   //argout typemap for const std::string&
86616
86617   return jresult;
86618 }
86619
86620
86621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
86622   void * jresult ;
86623   std::string *arg1 = 0 ;
86624   Dali::ImageDimensions arg2 ;
86625   Dali::ImageDimensions *argp2 ;
86626   Dali::PixelData result;
86627
86628   if (!jarg1) {
86629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86630     return 0;
86631   }
86632   std::string arg1_str(jarg1);
86633   arg1 = &arg1_str;
86634   argp2 = (Dali::ImageDimensions *)jarg2;
86635   if (!argp2) {
86636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86637     return 0;
86638   }
86639   arg2 = *argp2;
86640   {
86641     try {
86642       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
86643     } catch (std::out_of_range& e) {
86644       {
86645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86646       };
86647     } catch (std::exception& e) {
86648       {
86649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86650       };
86651     } catch (Dali::DaliException e) {
86652       {
86653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86654       };
86655     } catch (...) {
86656       {
86657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86658       };
86659     }
86660   }
86661
86662   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86663
86664   //argout typemap for const std::string&
86665
86666   return jresult;
86667 }
86668
86669
86670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
86671   void * jresult ;
86672   std::string *arg1 = 0 ;
86673   Dali::ImageDimensions arg2 ;
86674   Dali::FittingMode::Type arg3 ;
86675   Dali::SamplingMode::Type arg4 ;
86676   bool arg5 ;
86677   Dali::ImageDimensions *argp2 ;
86678   Dali::PixelData result;
86679
86680   if (!jarg1) {
86681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86682     return 0;
86683   }
86684   std::string arg1_str(jarg1);
86685   arg1 = &arg1_str;
86686   argp2 = (Dali::ImageDimensions *)jarg2;
86687   if (!argp2) {
86688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86689     return 0;
86690   }
86691   arg2 = *argp2;
86692   arg3 = (Dali::FittingMode::Type)jarg3;
86693   arg4 = (Dali::SamplingMode::Type)jarg4;
86694   arg5 = jarg5 ? true : false;
86695   {
86696     try {
86697       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
86698     } catch (std::out_of_range& e) {
86699       {
86700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86701       };
86702     } catch (std::exception& e) {
86703       {
86704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86705       };
86706     } catch (Dali::DaliException e) {
86707       {
86708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86709       };
86710     } catch (...) {
86711       {
86712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86713       };
86714     }
86715   }
86716
86717   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86718
86719   //argout typemap for const std::string&
86720
86721   return jresult;
86722 }
86723
86724
86725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
86726   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86727
86728   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86729   {
86730     try {
86731       delete arg1;
86732     } catch (std::out_of_range& e) {
86733       {
86734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86735       };
86736     } catch (std::exception& e) {
86737       {
86738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86739       };
86740     } catch (Dali::DaliException e) {
86741       {
86742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86743       };
86744     } catch (...) {
86745       {
86746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86747       };
86748     }
86749   }
86750
86751 }
86752
86753
86754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
86755   void * jresult ;
86756   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86757   Dali::Actor arg2 ;
86758   Dali::Actor arg3 ;
86759   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
86760   Dali::Actor *argp2 ;
86761   Dali::Actor *argp3 ;
86762   Dali::Actor result;
86763
86764   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86765   argp2 = (Dali::Actor *)jarg2;
86766   if (!argp2) {
86767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86768     return 0;
86769   }
86770   arg2 = *argp2;
86771   argp3 = (Dali::Actor *)jarg3;
86772   if (!argp3) {
86773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86774     return 0;
86775   }
86776   arg3 = *argp3;
86777   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
86778   {
86779     try {
86780       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
86781     } catch (std::out_of_range& e) {
86782       {
86783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86784       };
86785     } catch (std::exception& e) {
86786       {
86787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86788       };
86789     } catch (Dali::DaliException e) {
86790       {
86791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86792       };
86793     } catch (...) {
86794       {
86795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86796       };
86797     }
86798   }
86799
86800   jresult = new Dali::Actor((const Dali::Actor &)result);
86801   return jresult;
86802 }
86803
86804
86805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
86806   void * jresult ;
86807   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
86808
86809   {
86810     try {
86811       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
86812     } catch (std::out_of_range& e) {
86813       {
86814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86815       };
86816     } catch (std::exception& e) {
86817       {
86818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86819       };
86820     } catch (Dali::DaliException e) {
86821       {
86822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86823       };
86824     } catch (...) {
86825       {
86826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86827       };
86828     }
86829   }
86830
86831   jresult = (void *)result;
86832   return jresult;
86833 }
86834
86835
86836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
86837   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
86838   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
86839   if (director) {
86840     director->swig_connect_director(callback0);
86841   }
86842 }
86843
86844
86845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
86846   void * jresult ;
86847   Dali::FrameCallbackInterface *result = 0 ;
86848
86849   {
86850     try {
86851       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
86852     } catch (std::out_of_range& e) {
86853       {
86854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86855       };
86856     } catch (std::exception& e) {
86857       {
86858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86859       };
86860     } catch (Dali::DaliException e) {
86861       {
86862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86863       };
86864     } catch (...) {
86865       {
86866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86867       };
86868     }
86869   }
86870
86871   jresult = (void *)result;
86872   return jresult;
86873 }
86874
86875 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPosition(void * updateProxy, unsigned int id,  void* position) {
86876   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86877   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
86878   return proxy->GetPosition(id, *vector3);
86879 }
86880
86881 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetPosition(void * updateProxy, unsigned int id, void* position) {
86882   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86883   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
86884   return proxy->SetPosition(id, *vector3);
86885 }
86886
86887 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakePosition(void * updateProxy, unsigned int id, void* position) {
86888   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86889   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
86890   return proxy->BakePosition(id, *vector3);
86891 }
86892
86893 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetSize(void * updateProxy, unsigned int id, void* size) {
86894   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86895   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
86896   return proxy->GetSize(id, *vector3);
86897 }
86898
86899 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetSize(void * updateProxy, unsigned int id, void* size) {
86900   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86901   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
86902   return proxy->SetSize(id, *vector3);
86903 }
86904 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeSize(void * updateProxy, unsigned int id, void* size) {
86905   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86906   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
86907   return proxy->BakeSize(id, *vector3);
86908 }
86909
86910 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPositionAndSize(void * updateProxy, unsigned int id, void* position, void* size) {
86911   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86912   Dali::Vector3* vector3_pos = (Dali::Vector3 *)position;
86913   Dali::Vector3* vector3_size = (Dali::Vector3 *)size;
86914   return proxy->GetPositionAndSize(id, *vector3_pos, *vector3_size);
86915 }
86916
86917 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetScale(void * updateProxy, unsigned int id, void* scale) {
86918   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86919   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
86920   return proxy->GetScale(id,* vector3);
86921 }
86922
86923 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetScale(void * updateProxy, unsigned int id, void* scale) {
86924   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86925   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
86926   return proxy->SetScale(id, *vector3);
86927 }
86928
86929 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeScale(void * updateProxy, unsigned int id, void* scale) {
86930   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86931   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
86932   return proxy->BakeScale(id, *vector3);
86933 }
86934
86935 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetColor(void * updateProxy, unsigned int id, void* color) {
86936   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86937   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
86938   return proxy->GetColor(id, *vector4);
86939 }
86940
86941 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetColor(void * updateProxy, unsigned int id, void* color) {
86942   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86943   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
86944   return proxy->SetColor(id, *vector4);
86945 }
86946
86947 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeColor(void * updateProxy, unsigned int id, void* color) {
86948   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86949   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
86950   return proxy->BakeColor(id, *vector4);
86951 }
86952
86953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
86954   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
86955   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
86956
86957   Dali::Stage *arg1 = (Dali::Stage *) 0;
86958   Dali::Actor *arg3 = 0;
86959
86960   arg1 = (Dali::Stage *)jarg1;
86961   arg3 = (Dali::Actor *)jarg3;
86962
86963   DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
86964   return;
86965 }
86966
86967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
86968
86969   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
86970   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
86971
86972   Dali::Stage *arg1 = (Dali::Stage *) 0;
86973
86974   arg1 = (Dali::Stage *)jarg1;
86975
86976   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
86977   return;
86978 }
86979
86980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
86981   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
86982   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
86983   if (director) {
86984     director->swig_connect_director(callback0);
86985   }
86986 }
86987
86988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
86989   KeyboardFocusManager arg1 ;
86990   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
86991   KeyboardFocusManager *argp1 ;
86992
86993   argp1 = (KeyboardFocusManager *)jarg1;
86994   if (!argp1) {
86995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
86996     return ;
86997   }
86998   arg1 = *argp1;
86999   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
87000   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
87001   {
87002     try {
87003       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
87004     } catch (std::out_of_range& e) {
87005       {
87006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87007       };
87008     } catch (std::exception& e) {
87009       {
87010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87011       };
87012     } catch (Dali::DaliException e) {
87013       {
87014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87015       };
87016     } catch (...) {
87017       {
87018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87019       };
87020     }
87021   }
87022
87023 }
87024
87025
87026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
87027   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87028
87029   arg1 = (std::vector< unsigned int > *)jarg1;
87030   {
87031     try {
87032       (arg1)->clear();
87033     } catch (std::out_of_range& e) {
87034       {
87035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87036       };
87037     } catch (std::exception& e) {
87038       {
87039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87040       };
87041     } catch (Dali::DaliException e) {
87042       {
87043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87044       };
87045     } catch (...) {
87046       {
87047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87048       };
87049     }
87050   }
87051
87052 }
87053
87054
87055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
87056   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87057   unsigned int *arg2 = 0 ;
87058   unsigned int temp2 ;
87059
87060   arg1 = (std::vector< unsigned int > *)jarg1;
87061   temp2 = (unsigned int)jarg2;
87062   arg2 = &temp2;
87063   {
87064     try {
87065       (arg1)->push_back((unsigned int const &)*arg2);
87066     } catch (std::out_of_range& e) {
87067       {
87068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87069       };
87070     } catch (std::exception& e) {
87071       {
87072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87073       };
87074     } catch (Dali::DaliException e) {
87075       {
87076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87077       };
87078     } catch (...) {
87079       {
87080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87081       };
87082     }
87083   }
87084
87085 }
87086
87087
87088 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
87089   unsigned long jresult ;
87090   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87091   std::vector< unsigned int >::size_type result;
87092
87093   arg1 = (std::vector< unsigned int > *)jarg1;
87094   {
87095     try {
87096       result = ((std::vector< unsigned int > const *)arg1)->size();
87097     } catch (std::out_of_range& e) {
87098       {
87099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87100       };
87101     } catch (std::exception& e) {
87102       {
87103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87104       };
87105     } catch (Dali::DaliException e) {
87106       {
87107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87108       };
87109     } catch (...) {
87110       {
87111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87112       };
87113     }
87114   }
87115
87116   jresult = (unsigned long)result;
87117   return jresult;
87118 }
87119
87120
87121 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
87122   unsigned long jresult ;
87123   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87124   std::vector< unsigned int >::size_type result;
87125
87126   arg1 = (std::vector< unsigned int > *)jarg1;
87127   {
87128     try {
87129       result = ((std::vector< unsigned int > const *)arg1)->capacity();
87130     } catch (std::out_of_range& e) {
87131       {
87132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87133       };
87134     } catch (std::exception& e) {
87135       {
87136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87137       };
87138     } catch (Dali::DaliException e) {
87139       {
87140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87141       };
87142     } catch (...) {
87143       {
87144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87145       };
87146     }
87147   }
87148
87149   jresult = (unsigned long)result;
87150   return jresult;
87151 }
87152
87153
87154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
87155   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87156   std::vector< unsigned int >::size_type arg2 ;
87157
87158   arg1 = (std::vector< unsigned int > *)jarg1;
87159   arg2 = (std::vector< unsigned int >::size_type)jarg2;
87160   {
87161     try {
87162       (arg1)->reserve(arg2);
87163     } catch (std::out_of_range& e) {
87164       {
87165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87166       };
87167     } catch (std::exception& e) {
87168       {
87169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87170       };
87171     } catch (Dali::DaliException e) {
87172       {
87173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87174       };
87175     } catch (...) {
87176       {
87177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87178       };
87179     }
87180   }
87181
87182 }
87183
87184
87185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
87186   void * jresult ;
87187   std::vector< unsigned int > *result = 0 ;
87188
87189   {
87190     try {
87191       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
87192     } catch (std::out_of_range& e) {
87193       {
87194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87195       };
87196     } catch (std::exception& e) {
87197       {
87198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87199       };
87200     } catch (Dali::DaliException e) {
87201       {
87202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87203       };
87204     } catch (...) {
87205       {
87206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87207       };
87208     }
87209   }
87210
87211   jresult = (void *)result;
87212   return jresult;
87213 }
87214
87215
87216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
87217   void * jresult ;
87218   std::vector< unsigned int > *arg1 = 0 ;
87219   std::vector< unsigned int > *result = 0 ;
87220
87221   arg1 = (std::vector< unsigned int > *)jarg1;
87222   if (!arg1) {
87223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87224     return 0;
87225   }
87226   {
87227     try {
87228       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
87229     } catch (std::out_of_range& e) {
87230       {
87231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87232       };
87233     } catch (std::exception& e) {
87234       {
87235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87236       };
87237     } catch (Dali::DaliException e) {
87238       {
87239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87240       };
87241     } catch (...) {
87242       {
87243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87244       };
87245     }
87246   }
87247
87248   jresult = (void *)result;
87249   return jresult;
87250 }
87251
87252
87253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
87254   void * jresult ;
87255   int arg1 ;
87256   std::vector< unsigned int > *result = 0 ;
87257
87258   arg1 = (int)jarg1;
87259   {
87260     try {
87261       try {
87262         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
87263       }
87264       catch(std::out_of_range &_e) {
87265         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87266         return 0;
87267       }
87268
87269     } catch (std::out_of_range& e) {
87270       {
87271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87272       };
87273     } catch (std::exception& e) {
87274       {
87275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87276       };
87277     } catch (Dali::DaliException e) {
87278       {
87279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87280       };
87281     } catch (...) {
87282       {
87283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87284       };
87285     }
87286   }
87287
87288   jresult = (void *)result;
87289   return jresult;
87290 }
87291
87292
87293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
87294   unsigned int jresult ;
87295   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87296   int arg2 ;
87297   unsigned int result;
87298
87299   arg1 = (std::vector< unsigned int > *)jarg1;
87300   arg2 = (int)jarg2;
87301   {
87302     try {
87303       try {
87304         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
87305       }
87306       catch(std::out_of_range &_e) {
87307         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87308         return 0;
87309       }
87310
87311     } catch (std::out_of_range& e) {
87312       {
87313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87314       };
87315     } catch (std::exception& e) {
87316       {
87317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87318       };
87319     } catch (Dali::DaliException e) {
87320       {
87321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87322       };
87323     } catch (...) {
87324       {
87325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87326       };
87327     }
87328   }
87329
87330   jresult = result;
87331   return jresult;
87332 }
87333
87334
87335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
87336   unsigned int jresult ;
87337   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87338   int arg2 ;
87339   unsigned int *result = 0 ;
87340
87341   arg1 = (std::vector< unsigned int > *)jarg1;
87342   arg2 = (int)jarg2;
87343   {
87344     try {
87345       try {
87346         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
87347       }
87348       catch(std::out_of_range &_e) {
87349         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87350         return 0;
87351       }
87352
87353     } catch (std::out_of_range& e) {
87354       {
87355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87356       };
87357     } catch (std::exception& e) {
87358       {
87359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87360       };
87361     } catch (Dali::DaliException e) {
87362       {
87363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87364       };
87365     } catch (...) {
87366       {
87367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87368       };
87369     }
87370   }
87371
87372   jresult = *result;
87373   return jresult;
87374 }
87375
87376
87377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
87378   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87379   int arg2 ;
87380   unsigned int *arg3 = 0 ;
87381   unsigned int temp3 ;
87382
87383   arg1 = (std::vector< unsigned int > *)jarg1;
87384   arg2 = (int)jarg2;
87385   temp3 = (unsigned int)jarg3;
87386   arg3 = &temp3;
87387   {
87388     try {
87389       try {
87390         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
87391       }
87392       catch(std::out_of_range &_e) {
87393         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87394         return ;
87395       }
87396
87397     } catch (std::out_of_range& e) {
87398       {
87399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87400       };
87401     } catch (std::exception& e) {
87402       {
87403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87404       };
87405     } catch (Dali::DaliException e) {
87406       {
87407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87408       };
87409     } catch (...) {
87410       {
87411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87412       };
87413     }
87414   }
87415
87416 }
87417
87418
87419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
87420   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87421   std::vector< unsigned int > *arg2 = 0 ;
87422
87423   arg1 = (std::vector< unsigned int > *)jarg1;
87424   arg2 = (std::vector< unsigned int > *)jarg2;
87425   if (!arg2) {
87426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87427     return ;
87428   }
87429   {
87430     try {
87431       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
87432     } catch (std::out_of_range& e) {
87433       {
87434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87435       };
87436     } catch (std::exception& e) {
87437       {
87438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87439       };
87440     } catch (Dali::DaliException e) {
87441       {
87442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87443       };
87444     } catch (...) {
87445       {
87446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87447       };
87448     }
87449   }
87450
87451 }
87452
87453
87454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87455   void * jresult ;
87456   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87457   int arg2 ;
87458   int arg3 ;
87459   std::vector< unsigned int > *result = 0 ;
87460
87461   arg1 = (std::vector< unsigned int > *)jarg1;
87462   arg2 = (int)jarg2;
87463   arg3 = (int)jarg3;
87464   {
87465     try {
87466       try {
87467         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
87468       }
87469       catch(std::out_of_range &_e) {
87470         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87471         return 0;
87472       }
87473       catch(std::invalid_argument &_e) {
87474         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87475         return 0;
87476       }
87477
87478     } catch (std::out_of_range& e) {
87479       {
87480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87481       };
87482     } catch (std::exception& e) {
87483       {
87484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87485       };
87486     } catch (Dali::DaliException e) {
87487       {
87488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87489       };
87490     } catch (...) {
87491       {
87492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87493       };
87494     }
87495   }
87496
87497   jresult = (void *)result;
87498   return jresult;
87499 }
87500
87501
87502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
87503   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87504   int arg2 ;
87505   unsigned int *arg3 = 0 ;
87506   unsigned int temp3 ;
87507
87508   arg1 = (std::vector< unsigned int > *)jarg1;
87509   arg2 = (int)jarg2;
87510   temp3 = (unsigned int)jarg3;
87511   arg3 = &temp3;
87512   {
87513     try {
87514       try {
87515         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
87516       }
87517       catch(std::out_of_range &_e) {
87518         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87519         return ;
87520       }
87521
87522     } catch (std::out_of_range& e) {
87523       {
87524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87525       };
87526     } catch (std::exception& e) {
87527       {
87528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87529       };
87530     } catch (Dali::DaliException e) {
87531       {
87532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87533       };
87534     } catch (...) {
87535       {
87536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87537       };
87538     }
87539   }
87540
87541 }
87542
87543
87544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87545   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87546   int arg2 ;
87547   std::vector< unsigned int > *arg3 = 0 ;
87548
87549   arg1 = (std::vector< unsigned int > *)jarg1;
87550   arg2 = (int)jarg2;
87551   arg3 = (std::vector< unsigned int > *)jarg3;
87552   if (!arg3) {
87553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87554     return ;
87555   }
87556   {
87557     try {
87558       try {
87559         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87560       }
87561       catch(std::out_of_range &_e) {
87562         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87563         return ;
87564       }
87565
87566     } catch (std::out_of_range& e) {
87567       {
87568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87569       };
87570     } catch (std::exception& e) {
87571       {
87572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87573       };
87574     } catch (Dali::DaliException e) {
87575       {
87576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87577       };
87578     } catch (...) {
87579       {
87580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87581       };
87582     }
87583   }
87584
87585 }
87586
87587
87588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
87589   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87590   int arg2 ;
87591
87592   arg1 = (std::vector< unsigned int > *)jarg1;
87593   arg2 = (int)jarg2;
87594   {
87595     try {
87596       try {
87597         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
87598       }
87599       catch(std::out_of_range &_e) {
87600         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87601         return ;
87602       }
87603
87604     } catch (std::out_of_range& e) {
87605       {
87606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87607       };
87608     } catch (std::exception& e) {
87609       {
87610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87611       };
87612     } catch (Dali::DaliException e) {
87613       {
87614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87615       };
87616     } catch (...) {
87617       {
87618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87619       };
87620     }
87621   }
87622
87623 }
87624
87625
87626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87627   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87628   int arg2 ;
87629   int arg3 ;
87630
87631   arg1 = (std::vector< unsigned int > *)jarg1;
87632   arg2 = (int)jarg2;
87633   arg3 = (int)jarg3;
87634   {
87635     try {
87636       try {
87637         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
87638       }
87639       catch(std::out_of_range &_e) {
87640         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87641         return ;
87642       }
87643       catch(std::invalid_argument &_e) {
87644         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87645         return ;
87646       }
87647
87648     } catch (std::out_of_range& e) {
87649       {
87650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87651       };
87652     } catch (std::exception& e) {
87653       {
87654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87655       };
87656     } catch (Dali::DaliException e) {
87657       {
87658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87659       };
87660     } catch (...) {
87661       {
87662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87663       };
87664     }
87665   }
87666
87667 }
87668
87669
87670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
87671   void * jresult ;
87672   unsigned int *arg1 = 0 ;
87673   int arg2 ;
87674   unsigned int temp1 ;
87675   std::vector< unsigned int > *result = 0 ;
87676
87677   temp1 = (unsigned int)jarg1;
87678   arg1 = &temp1;
87679   arg2 = (int)jarg2;
87680   {
87681     try {
87682       try {
87683         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
87684       }
87685       catch(std::out_of_range &_e) {
87686         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87687         return 0;
87688       }
87689
87690     } catch (std::out_of_range& e) {
87691       {
87692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87693       };
87694     } catch (std::exception& e) {
87695       {
87696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87697       };
87698     } catch (Dali::DaliException e) {
87699       {
87700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87701       };
87702     } catch (...) {
87703       {
87704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87705       };
87706     }
87707   }
87708
87709   jresult = (void *)result;
87710   return jresult;
87711 }
87712
87713
87714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
87715   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87716
87717   arg1 = (std::vector< unsigned int > *)jarg1;
87718   {
87719     try {
87720       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
87721     } catch (std::out_of_range& e) {
87722       {
87723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87724       };
87725     } catch (std::exception& e) {
87726       {
87727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87728       };
87729     } catch (Dali::DaliException e) {
87730       {
87731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87732       };
87733     } catch (...) {
87734       {
87735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87736       };
87737     }
87738   }
87739
87740 }
87741
87742
87743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87744   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87745   int arg2 ;
87746   int arg3 ;
87747
87748   arg1 = (std::vector< unsigned int > *)jarg1;
87749   arg2 = (int)jarg2;
87750   arg3 = (int)jarg3;
87751   {
87752     try {
87753       try {
87754         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87755       }
87756       catch(std::out_of_range &_e) {
87757         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87758         return ;
87759       }
87760       catch(std::invalid_argument &_e) {
87761         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87762         return ;
87763       }
87764
87765     } catch (std::out_of_range& e) {
87766       {
87767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87768       };
87769     } catch (std::exception& e) {
87770       {
87771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87772       };
87773     } catch (Dali::DaliException e) {
87774       {
87775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87776       };
87777     } catch (...) {
87778       {
87779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87780       };
87781     }
87782   }
87783
87784 }
87785
87786
87787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87788   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87789   int arg2 ;
87790   std::vector< unsigned int > *arg3 = 0 ;
87791
87792   arg1 = (std::vector< unsigned int > *)jarg1;
87793   arg2 = (int)jarg2;
87794   arg3 = (std::vector< unsigned int > *)jarg3;
87795   if (!arg3) {
87796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87797     return ;
87798   }
87799   {
87800     try {
87801       try {
87802         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87803       }
87804       catch(std::out_of_range &_e) {
87805         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87806         return ;
87807       }
87808
87809     } catch (std::out_of_range& e) {
87810       {
87811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87812       };
87813     } catch (std::exception& e) {
87814       {
87815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87816       };
87817     } catch (Dali::DaliException e) {
87818       {
87819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87820       };
87821     } catch (...) {
87822       {
87823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87824       };
87825     }
87826   }
87827
87828 }
87829
87830
87831 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
87832   unsigned int jresult ;
87833   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87834   unsigned int *arg2 = 0 ;
87835   unsigned int temp2 ;
87836   bool result;
87837
87838   arg1 = (std::vector< unsigned int > *)jarg1;
87839   temp2 = (unsigned int)jarg2;
87840   arg2 = &temp2;
87841   {
87842     try {
87843       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
87844     } catch (std::out_of_range& e) {
87845       {
87846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87847       };
87848     } catch (std::exception& e) {
87849       {
87850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87851       };
87852     } catch (Dali::DaliException e) {
87853       {
87854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87855       };
87856     } catch (...) {
87857       {
87858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87859       };
87860     }
87861   }
87862
87863   jresult = result;
87864   return jresult;
87865 }
87866
87867
87868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
87869   int jresult ;
87870   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87871   unsigned int *arg2 = 0 ;
87872   unsigned int temp2 ;
87873   int result;
87874
87875   arg1 = (std::vector< unsigned int > *)jarg1;
87876   temp2 = (unsigned int)jarg2;
87877   arg2 = &temp2;
87878   {
87879     try {
87880       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
87881     } catch (std::out_of_range& e) {
87882       {
87883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87884       };
87885     } catch (std::exception& e) {
87886       {
87887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87888       };
87889     } catch (Dali::DaliException e) {
87890       {
87891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87892       };
87893     } catch (...) {
87894       {
87895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87896       };
87897     }
87898   }
87899
87900   jresult = result;
87901   return jresult;
87902 }
87903
87904
87905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
87906   int jresult ;
87907   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87908   unsigned int *arg2 = 0 ;
87909   unsigned int temp2 ;
87910   int result;
87911
87912   arg1 = (std::vector< unsigned int > *)jarg1;
87913   temp2 = (unsigned int)jarg2;
87914   arg2 = &temp2;
87915   {
87916     try {
87917       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
87918     } catch (std::out_of_range& e) {
87919       {
87920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87921       };
87922     } catch (std::exception& e) {
87923       {
87924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87925       };
87926     } catch (Dali::DaliException e) {
87927       {
87928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87929       };
87930     } catch (...) {
87931       {
87932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87933       };
87934     }
87935   }
87936
87937   jresult = result;
87938   return jresult;
87939 }
87940
87941
87942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
87943   unsigned int jresult ;
87944   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87945   unsigned int *arg2 = 0 ;
87946   unsigned int temp2 ;
87947   bool result;
87948
87949   arg1 = (std::vector< unsigned int > *)jarg1;
87950   temp2 = (unsigned int)jarg2;
87951   arg2 = &temp2;
87952   {
87953     try {
87954       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
87955     } catch (std::out_of_range& e) {
87956       {
87957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87958       };
87959     } catch (std::exception& e) {
87960       {
87961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87962       };
87963     } catch (Dali::DaliException e) {
87964       {
87965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87966       };
87967     } catch (...) {
87968       {
87969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87970       };
87971     }
87972   }
87973
87974   jresult = result;
87975   return jresult;
87976 }
87977
87978
87979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
87980   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87981
87982   arg1 = (std::vector< unsigned int > *)jarg1;
87983   {
87984     try {
87985       delete arg1;
87986     } catch (std::out_of_range& e) {
87987       {
87988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87989       };
87990     } catch (std::exception& e) {
87991       {
87992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87993       };
87994     } catch (Dali::DaliException e) {
87995       {
87996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87997       };
87998     } catch (...) {
87999       {
88000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88001       };
88002     }
88003   }
88004
88005 }
88006
88007
88008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
88009   void * jresult ;
88010   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88011
88012   {
88013     try {
88014       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
88015     } catch (std::out_of_range& e) {
88016       {
88017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88018       };
88019     } catch (std::exception& e) {
88020       {
88021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88022       };
88023     } catch (Dali::DaliException e) {
88024       {
88025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88026       };
88027     } catch (...) {
88028       {
88029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88030       };
88031     }
88032   }
88033
88034   jresult = (void *)result;
88035   return jresult;
88036 }
88037
88038
88039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
88040   void * jresult ;
88041   unsigned int arg1 ;
88042   Dali::Actor arg2 ;
88043   Dali::Actor *argp2 ;
88044   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88045
88046   arg1 = (unsigned int)jarg1;
88047   argp2 = (Dali::Actor *)jarg2;
88048   if (!argp2) {
88049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88050     return 0;
88051   }
88052   arg2 = *argp2;
88053   {
88054     try {
88055       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
88056     } catch (std::out_of_range& e) {
88057       {
88058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88059       };
88060     } catch (std::exception& e) {
88061       {
88062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88063       };
88064     } catch (Dali::DaliException e) {
88065       {
88066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88067       };
88068     } catch (...) {
88069       {
88070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88071       };
88072     }
88073   }
88074
88075   jresult = (void *)result;
88076   return jresult;
88077 }
88078
88079
88080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
88081   void * jresult ;
88082   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88083   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88084
88085   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88086   if (!arg1) {
88087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88088     return 0;
88089   }
88090   {
88091     try {
88092       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
88093     } catch (std::out_of_range& e) {
88094       {
88095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88096       };
88097     } catch (std::exception& e) {
88098       {
88099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88100       };
88101     } catch (Dali::DaliException e) {
88102       {
88103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88104       };
88105     } catch (...) {
88106       {
88107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88108       };
88109     }
88110   }
88111
88112   jresult = (void *)result;
88113   return jresult;
88114 }
88115
88116
88117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
88118   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88119   unsigned int arg2 ;
88120
88121   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88122   arg2 = (unsigned int)jarg2;
88123   if (arg1) (arg1)->first = arg2;
88124 }
88125
88126
88127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
88128   unsigned int jresult ;
88129   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88130   unsigned int result;
88131
88132   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88133   result = (unsigned int) ((arg1)->first);
88134   jresult = result;
88135   return jresult;
88136 }
88137
88138
88139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
88140   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88141   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
88142
88143   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88144   arg2 = (Dali::Actor *)jarg2;
88145   if (arg1) (arg1)->second = *arg2;
88146 }
88147
88148
88149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
88150   void * jresult ;
88151   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88152   Dali::Actor *result = 0 ;
88153
88154   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88155   result = (Dali::Actor *)& ((arg1)->second);
88156   jresult = (void *)result;
88157   return jresult;
88158 }
88159
88160
88161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
88162   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88163
88164   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88165   {
88166     try {
88167       delete arg1;
88168     } catch (std::out_of_range& e) {
88169       {
88170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88171       };
88172     } catch (std::exception& e) {
88173       {
88174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88175       };
88176     } catch (Dali::DaliException e) {
88177       {
88178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88179       };
88180     } catch (...) {
88181       {
88182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88183       };
88184     }
88185   }
88186
88187 }
88188
88189
88190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
88191   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88192
88193   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88194   {
88195     try {
88196       (arg1)->clear();
88197     } catch (std::out_of_range& e) {
88198       {
88199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88200       };
88201     } catch (std::exception& e) {
88202       {
88203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88204       };
88205     } catch (Dali::DaliException e) {
88206       {
88207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88208       };
88209     } catch (...) {
88210       {
88211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88212       };
88213     }
88214   }
88215
88216 }
88217
88218
88219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
88220   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88221   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
88222
88223   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88224   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
88225   if (!arg2) {
88226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88227     return ;
88228   }
88229   {
88230     try {
88231       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
88232     } catch (std::out_of_range& e) {
88233       {
88234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88235       };
88236     } catch (std::exception& e) {
88237       {
88238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88239       };
88240     } catch (Dali::DaliException e) {
88241       {
88242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88243       };
88244     } catch (...) {
88245       {
88246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88247       };
88248     }
88249   }
88250
88251 }
88252
88253
88254 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
88255   unsigned long jresult ;
88256   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88257   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88258
88259   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88260   {
88261     try {
88262       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
88263     } catch (std::out_of_range& e) {
88264       {
88265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88266       };
88267     } catch (std::exception& e) {
88268       {
88269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88270       };
88271     } catch (Dali::DaliException e) {
88272       {
88273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88274       };
88275     } catch (...) {
88276       {
88277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88278       };
88279     }
88280   }
88281
88282   jresult = (unsigned long)result;
88283   return jresult;
88284 }
88285
88286
88287 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
88288   unsigned long jresult ;
88289   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88290   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88291
88292   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88293   {
88294     try {
88295       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
88296     } catch (std::out_of_range& e) {
88297       {
88298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88299       };
88300     } catch (std::exception& e) {
88301       {
88302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88303       };
88304     } catch (Dali::DaliException e) {
88305       {
88306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88307       };
88308     } catch (...) {
88309       {
88310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88311       };
88312     }
88313   }
88314
88315   jresult = (unsigned long)result;
88316   return jresult;
88317 }
88318
88319
88320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
88321   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88322   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
88323
88324   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88325   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
88326   {
88327     try {
88328       (arg1)->reserve(arg2);
88329     } catch (std::out_of_range& e) {
88330       {
88331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88332       };
88333     } catch (std::exception& e) {
88334       {
88335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88336       };
88337     } catch (Dali::DaliException e) {
88338       {
88339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88340       };
88341     } catch (...) {
88342       {
88343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88344       };
88345     }
88346   }
88347
88348 }
88349
88350
88351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
88352   void * jresult ;
88353   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88354
88355   {
88356     try {
88357       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
88358     } catch (std::out_of_range& e) {
88359       {
88360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88361       };
88362     } catch (std::exception& e) {
88363       {
88364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88365       };
88366     } catch (Dali::DaliException e) {
88367       {
88368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88369       };
88370     } catch (...) {
88371       {
88372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88373       };
88374     }
88375   }
88376
88377   jresult = (void *)result;
88378   return jresult;
88379 }
88380
88381
88382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
88383   void * jresult ;
88384   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
88385   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88386
88387   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88388   if (!arg1) {
88389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88390     return 0;
88391   }
88392   {
88393     try {
88394       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);
88395     } catch (std::out_of_range& e) {
88396       {
88397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88398       };
88399     } catch (std::exception& e) {
88400       {
88401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88402       };
88403     } catch (Dali::DaliException e) {
88404       {
88405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88406       };
88407     } catch (...) {
88408       {
88409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88410       };
88411     }
88412   }
88413
88414   jresult = (void *)result;
88415   return jresult;
88416 }
88417
88418
88419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
88420   void * jresult ;
88421   int arg1 ;
88422   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88423
88424   arg1 = (int)jarg1;
88425   {
88426     try {
88427       try {
88428         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);
88429       }
88430       catch(std::out_of_range &_e) {
88431         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88432         return 0;
88433       }
88434
88435     } catch (std::out_of_range& e) {
88436       {
88437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88438       };
88439     } catch (std::exception& e) {
88440       {
88441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88442       };
88443     } catch (Dali::DaliException e) {
88444       {
88445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88446       };
88447     } catch (...) {
88448       {
88449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88450       };
88451     }
88452   }
88453
88454   jresult = (void *)result;
88455   return jresult;
88456 }
88457
88458
88459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
88460   void * jresult ;
88461   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88462   int arg2 ;
88463   std::pair< unsigned int,Dali::Actor > result;
88464
88465   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88466   arg2 = (int)jarg2;
88467   {
88468     try {
88469       try {
88470         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
88471       }
88472       catch(std::out_of_range &_e) {
88473         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88474         return 0;
88475       }
88476
88477     } catch (std::out_of_range& e) {
88478       {
88479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88480       };
88481     } catch (std::exception& e) {
88482       {
88483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88484       };
88485     } catch (Dali::DaliException e) {
88486       {
88487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88488       };
88489     } catch (...) {
88490       {
88491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88492       };
88493     }
88494   }
88495
88496   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
88497   return jresult;
88498 }
88499
88500
88501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
88502   void * jresult ;
88503   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88504   int arg2 ;
88505   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88506
88507   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88508   arg2 = (int)jarg2;
88509   {
88510     try {
88511       try {
88512         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
88513       }
88514       catch(std::out_of_range &_e) {
88515         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88516         return 0;
88517       }
88518
88519     } catch (std::out_of_range& e) {
88520       {
88521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88522       };
88523     } catch (std::exception& e) {
88524       {
88525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88526       };
88527     } catch (Dali::DaliException e) {
88528       {
88529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88530       };
88531     } catch (...) {
88532       {
88533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88534       };
88535     }
88536   }
88537
88538   jresult = (void *)result;
88539   return jresult;
88540 }
88541
88542
88543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88544   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88545   int arg2 ;
88546   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88547
88548   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88549   arg2 = (int)jarg2;
88550   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88551   if (!arg3) {
88552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88553     return ;
88554   }
88555   {
88556     try {
88557       try {
88558         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);
88559       }
88560       catch(std::out_of_range &_e) {
88561         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88562         return ;
88563       }
88564
88565     } catch (std::out_of_range& e) {
88566       {
88567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88568       };
88569     } catch (std::exception& e) {
88570       {
88571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88572       };
88573     } catch (Dali::DaliException e) {
88574       {
88575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88576       };
88577     } catch (...) {
88578       {
88579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88580       };
88581     }
88582   }
88583
88584 }
88585
88586
88587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
88588   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88589   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
88590
88591   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88592   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
88593   if (!arg2) {
88594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88595     return ;
88596   }
88597   {
88598     try {
88599       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);
88600     } catch (std::out_of_range& e) {
88601       {
88602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88603       };
88604     } catch (std::exception& e) {
88605       {
88606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88607       };
88608     } catch (Dali::DaliException e) {
88609       {
88610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88611       };
88612     } catch (...) {
88613       {
88614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88615       };
88616     }
88617   }
88618
88619 }
88620
88621
88622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88623   void * jresult ;
88624   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88625   int arg2 ;
88626   int arg3 ;
88627   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88628
88629   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88630   arg2 = (int)jarg2;
88631   arg3 = (int)jarg3;
88632   {
88633     try {
88634       try {
88635         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);
88636       }
88637       catch(std::out_of_range &_e) {
88638         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88639         return 0;
88640       }
88641       catch(std::invalid_argument &_e) {
88642         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88643         return 0;
88644       }
88645
88646     } catch (std::out_of_range& e) {
88647       {
88648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88649       };
88650     } catch (std::exception& e) {
88651       {
88652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88653       };
88654     } catch (Dali::DaliException e) {
88655       {
88656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88657       };
88658     } catch (...) {
88659       {
88660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88661       };
88662     }
88663   }
88664
88665   jresult = (void *)result;
88666   return jresult;
88667 }
88668
88669
88670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88671   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88672   int arg2 ;
88673   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88674
88675   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88676   arg2 = (int)jarg2;
88677   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88678   if (!arg3) {
88679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88680     return ;
88681   }
88682   {
88683     try {
88684       try {
88685         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);
88686       }
88687       catch(std::out_of_range &_e) {
88688         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88689         return ;
88690       }
88691
88692     } catch (std::out_of_range& e) {
88693       {
88694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88695       };
88696     } catch (std::exception& e) {
88697       {
88698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88699       };
88700     } catch (Dali::DaliException e) {
88701       {
88702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88703       };
88704     } catch (...) {
88705       {
88706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88707       };
88708     }
88709   }
88710
88711 }
88712
88713
88714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88715   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88716   int arg2 ;
88717   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88718
88719   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88720   arg2 = (int)jarg2;
88721   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88722   if (!arg3) {
88723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88724     return ;
88725   }
88726   {
88727     try {
88728       try {
88729         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);
88730       }
88731       catch(std::out_of_range &_e) {
88732         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88733         return ;
88734       }
88735
88736     } catch (std::out_of_range& e) {
88737       {
88738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88739       };
88740     } catch (std::exception& e) {
88741       {
88742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88743       };
88744     } catch (Dali::DaliException e) {
88745       {
88746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88747       };
88748     } catch (...) {
88749       {
88750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88751       };
88752     }
88753   }
88754
88755 }
88756
88757
88758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
88759   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88760   int arg2 ;
88761
88762   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88763   arg2 = (int)jarg2;
88764   {
88765     try {
88766       try {
88767         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
88768       }
88769       catch(std::out_of_range &_e) {
88770         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88771         return ;
88772       }
88773
88774     } catch (std::out_of_range& e) {
88775       {
88776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88777       };
88778     } catch (std::exception& e) {
88779       {
88780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88781       };
88782     } catch (Dali::DaliException e) {
88783       {
88784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88785       };
88786     } catch (...) {
88787       {
88788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88789       };
88790     }
88791   }
88792
88793 }
88794
88795
88796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88797   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88798   int arg2 ;
88799   int arg3 ;
88800
88801   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88802   arg2 = (int)jarg2;
88803   arg3 = (int)jarg3;
88804   {
88805     try {
88806       try {
88807         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
88808       }
88809       catch(std::out_of_range &_e) {
88810         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88811         return ;
88812       }
88813       catch(std::invalid_argument &_e) {
88814         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88815         return ;
88816       }
88817
88818     } catch (std::out_of_range& e) {
88819       {
88820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88821       };
88822     } catch (std::exception& e) {
88823       {
88824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88825       };
88826     } catch (Dali::DaliException e) {
88827       {
88828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88829       };
88830     } catch (...) {
88831       {
88832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88833       };
88834     }
88835   }
88836
88837 }
88838
88839
88840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
88841   void * jresult ;
88842   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88843   int arg2 ;
88844   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88845
88846   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88847   if (!arg1) {
88848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88849     return 0;
88850   }
88851   arg2 = (int)jarg2;
88852   {
88853     try {
88854       try {
88855         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);
88856       }
88857       catch(std::out_of_range &_e) {
88858         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88859         return 0;
88860       }
88861
88862     } catch (std::out_of_range& e) {
88863       {
88864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88865       };
88866     } catch (std::exception& e) {
88867       {
88868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88869       };
88870     } catch (Dali::DaliException e) {
88871       {
88872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88873       };
88874     } catch (...) {
88875       {
88876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88877       };
88878     }
88879   }
88880
88881   jresult = (void *)result;
88882   return jresult;
88883 }
88884
88885
88886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
88887   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88888
88889   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88890   {
88891     try {
88892       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
88893     } catch (std::out_of_range& e) {
88894       {
88895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88896       };
88897     } catch (std::exception& e) {
88898       {
88899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88900       };
88901     } catch (Dali::DaliException e) {
88902       {
88903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88904       };
88905     } catch (...) {
88906       {
88907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88908       };
88909     }
88910   }
88911
88912 }
88913
88914
88915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
88916   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88917   int arg2 ;
88918   int arg3 ;
88919
88920   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88921   arg2 = (int)jarg2;
88922   arg3 = (int)jarg3;
88923   {
88924     try {
88925       try {
88926         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88927       }
88928       catch(std::out_of_range &_e) {
88929         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88930         return ;
88931       }
88932       catch(std::invalid_argument &_e) {
88933         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88934         return ;
88935       }
88936
88937     } catch (std::out_of_range& e) {
88938       {
88939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88940       };
88941     } catch (std::exception& e) {
88942       {
88943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88944       };
88945     } catch (Dali::DaliException e) {
88946       {
88947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88948       };
88949     } catch (...) {
88950       {
88951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88952       };
88953     }
88954   }
88955
88956 }
88957
88958
88959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88960   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88961   int arg2 ;
88962   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88963
88964   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88965   arg2 = (int)jarg2;
88966   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88967   if (!arg3) {
88968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88969     return ;
88970   }
88971   {
88972     try {
88973       try {
88974         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);
88975       }
88976       catch(std::out_of_range &_e) {
88977         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88978         return ;
88979       }
88980
88981     } catch (std::out_of_range& e) {
88982       {
88983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88984       };
88985     } catch (std::exception& e) {
88986       {
88987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88988       };
88989     } catch (Dali::DaliException e) {
88990       {
88991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88992       };
88993     } catch (...) {
88994       {
88995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88996       };
88997     }
88998   }
88999
89000 }
89001
89002
89003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
89004   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89005
89006   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89007   {
89008     try {
89009       delete arg1;
89010     } catch (std::out_of_range& e) {
89011       {
89012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89013       };
89014     } catch (std::exception& e) {
89015       {
89016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89017       };
89018     } catch (Dali::DaliException e) {
89019       {
89020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89021       };
89022     } catch (...) {
89023       {
89024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89025       };
89026     }
89027   }
89028
89029 }
89030
89031
89032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
89033   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89034
89035   arg1 = (std::vector< Dali::Actor > *)jarg1;
89036   {
89037     try {
89038       (arg1)->clear();
89039     } catch (std::out_of_range& e) {
89040       {
89041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89042       };
89043     } catch (std::exception& e) {
89044       {
89045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89046       };
89047     } catch (Dali::DaliException e) {
89048       {
89049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89050       };
89051     } catch (...) {
89052       {
89053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89054       };
89055     }
89056   }
89057
89058 }
89059
89060
89061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
89062   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89063   Dali::Actor *arg2 = 0 ;
89064
89065   arg1 = (std::vector< Dali::Actor > *)jarg1;
89066   arg2 = (Dali::Actor *)jarg2;
89067   if (!arg2) {
89068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89069     return ;
89070   }
89071   {
89072     try {
89073       (arg1)->push_back((Dali::Actor const &)*arg2);
89074     } catch (std::out_of_range& e) {
89075       {
89076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89077       };
89078     } catch (std::exception& e) {
89079       {
89080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89081       };
89082     } catch (Dali::DaliException e) {
89083       {
89084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89085       };
89086     } catch (...) {
89087       {
89088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89089       };
89090     }
89091   }
89092
89093 }
89094
89095
89096 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
89097   unsigned long jresult ;
89098   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89099   std::vector< Dali::Actor >::size_type result;
89100
89101   arg1 = (std::vector< Dali::Actor > *)jarg1;
89102   {
89103     try {
89104       result = ((std::vector< Dali::Actor > const *)arg1)->size();
89105     } catch (std::out_of_range& e) {
89106       {
89107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89108       };
89109     } catch (std::exception& e) {
89110       {
89111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89112       };
89113     } catch (Dali::DaliException e) {
89114       {
89115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89116       };
89117     } catch (...) {
89118       {
89119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89120       };
89121     }
89122   }
89123
89124   jresult = (unsigned long)result;
89125   return jresult;
89126 }
89127
89128
89129 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
89130   unsigned long jresult ;
89131   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89132   std::vector< Dali::Actor >::size_type result;
89133
89134   arg1 = (std::vector< Dali::Actor > *)jarg1;
89135   {
89136     try {
89137       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
89138     } catch (std::out_of_range& e) {
89139       {
89140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89141       };
89142     } catch (std::exception& e) {
89143       {
89144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89145       };
89146     } catch (Dali::DaliException e) {
89147       {
89148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89149       };
89150     } catch (...) {
89151       {
89152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89153       };
89154     }
89155   }
89156
89157   jresult = (unsigned long)result;
89158   return jresult;
89159 }
89160
89161
89162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
89163   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89164   std::vector< Dali::Actor >::size_type arg2 ;
89165
89166   arg1 = (std::vector< Dali::Actor > *)jarg1;
89167   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
89168   {
89169     try {
89170       (arg1)->reserve(arg2);
89171     } catch (std::out_of_range& e) {
89172       {
89173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89174       };
89175     } catch (std::exception& e) {
89176       {
89177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89178       };
89179     } catch (Dali::DaliException e) {
89180       {
89181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89182       };
89183     } catch (...) {
89184       {
89185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89186       };
89187     }
89188   }
89189
89190 }
89191
89192
89193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
89194   void * jresult ;
89195   std::vector< Dali::Actor > *result = 0 ;
89196
89197   {
89198     try {
89199       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
89200     } catch (std::out_of_range& e) {
89201       {
89202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89203       };
89204     } catch (std::exception& e) {
89205       {
89206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89207       };
89208     } catch (Dali::DaliException e) {
89209       {
89210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89211       };
89212     } catch (...) {
89213       {
89214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89215       };
89216     }
89217   }
89218
89219   jresult = (void *)result;
89220   return jresult;
89221 }
89222
89223
89224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
89225   void * jresult ;
89226   std::vector< Dali::Actor > *arg1 = 0 ;
89227   std::vector< Dali::Actor > *result = 0 ;
89228
89229   arg1 = (std::vector< Dali::Actor > *)jarg1;
89230   if (!arg1) {
89231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89232     return 0;
89233   }
89234   {
89235     try {
89236       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
89237     } catch (std::out_of_range& e) {
89238       {
89239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89240       };
89241     } catch (std::exception& e) {
89242       {
89243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89244       };
89245     } catch (Dali::DaliException e) {
89246       {
89247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89248       };
89249     } catch (...) {
89250       {
89251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89252       };
89253     }
89254   }
89255
89256   jresult = (void *)result;
89257   return jresult;
89258 }
89259
89260
89261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
89262   void * jresult ;
89263   int arg1 ;
89264   std::vector< Dali::Actor > *result = 0 ;
89265
89266   arg1 = (int)jarg1;
89267   {
89268     try {
89269       try {
89270         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
89271       }
89272       catch(std::out_of_range &_e) {
89273         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89274         return 0;
89275       }
89276
89277     } catch (std::out_of_range& e) {
89278       {
89279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89280       };
89281     } catch (std::exception& e) {
89282       {
89283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89284       };
89285     } catch (Dali::DaliException e) {
89286       {
89287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89288       };
89289     } catch (...) {
89290       {
89291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89292       };
89293     }
89294   }
89295
89296   jresult = (void *)result;
89297   return jresult;
89298 }
89299
89300
89301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
89302   void * jresult ;
89303   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89304   int arg2 ;
89305   Dali::Actor result;
89306
89307   arg1 = (std::vector< Dali::Actor > *)jarg1;
89308   arg2 = (int)jarg2;
89309   {
89310     try {
89311       try {
89312         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
89313       }
89314       catch(std::out_of_range &_e) {
89315         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89316         return 0;
89317       }
89318
89319     } catch (std::out_of_range& e) {
89320       {
89321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89322       };
89323     } catch (std::exception& e) {
89324       {
89325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89326       };
89327     } catch (Dali::DaliException e) {
89328       {
89329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89330       };
89331     } catch (...) {
89332       {
89333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89334       };
89335     }
89336   }
89337
89338   jresult = new Dali::Actor((const Dali::Actor &)result);
89339   return jresult;
89340 }
89341
89342
89343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
89344   void * jresult ;
89345   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89346   int arg2 ;
89347   Dali::Actor *result = 0 ;
89348
89349   arg1 = (std::vector< Dali::Actor > *)jarg1;
89350   arg2 = (int)jarg2;
89351   {
89352     try {
89353       try {
89354         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
89355       }
89356       catch(std::out_of_range &_e) {
89357         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89358         return 0;
89359       }
89360
89361     } catch (std::out_of_range& e) {
89362       {
89363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89364       };
89365     } catch (std::exception& e) {
89366       {
89367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89368       };
89369     } catch (Dali::DaliException e) {
89370       {
89371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89372       };
89373     } catch (...) {
89374       {
89375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89376       };
89377     }
89378   }
89379
89380   jresult = (void *)result;
89381   return jresult;
89382 }
89383
89384
89385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
89386   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89387   int arg2 ;
89388   Dali::Actor *arg3 = 0 ;
89389
89390   arg1 = (std::vector< Dali::Actor > *)jarg1;
89391   arg2 = (int)jarg2;
89392   arg3 = (Dali::Actor *)jarg3;
89393   if (!arg3) {
89394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89395     return ;
89396   }
89397   {
89398     try {
89399       try {
89400         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
89401       }
89402       catch(std::out_of_range &_e) {
89403         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89404         return ;
89405       }
89406
89407     } catch (std::out_of_range& e) {
89408       {
89409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89410       };
89411     } catch (std::exception& e) {
89412       {
89413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89414       };
89415     } catch (Dali::DaliException e) {
89416       {
89417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89418       };
89419     } catch (...) {
89420       {
89421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89422       };
89423     }
89424   }
89425
89426 }
89427
89428
89429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
89430   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89431   std::vector< Dali::Actor > *arg2 = 0 ;
89432
89433   arg1 = (std::vector< Dali::Actor > *)jarg1;
89434   arg2 = (std::vector< Dali::Actor > *)jarg2;
89435   if (!arg2) {
89436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89437     return ;
89438   }
89439   {
89440     try {
89441       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
89442     } catch (std::out_of_range& e) {
89443       {
89444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89445       };
89446     } catch (std::exception& e) {
89447       {
89448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89449       };
89450     } catch (Dali::DaliException e) {
89451       {
89452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89453       };
89454     } catch (...) {
89455       {
89456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89457       };
89458     }
89459   }
89460
89461 }
89462
89463
89464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
89465   void * jresult ;
89466   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89467   int arg2 ;
89468   int arg3 ;
89469   std::vector< Dali::Actor > *result = 0 ;
89470
89471   arg1 = (std::vector< Dali::Actor > *)jarg1;
89472   arg2 = (int)jarg2;
89473   arg3 = (int)jarg3;
89474   {
89475     try {
89476       try {
89477         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
89478       }
89479       catch(std::out_of_range &_e) {
89480         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89481         return 0;
89482       }
89483       catch(std::invalid_argument &_e) {
89484         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89485         return 0;
89486       }
89487
89488     } catch (std::out_of_range& e) {
89489       {
89490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89491       };
89492     } catch (std::exception& e) {
89493       {
89494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89495       };
89496     } catch (Dali::DaliException e) {
89497       {
89498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89499       };
89500     } catch (...) {
89501       {
89502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89503       };
89504     }
89505   }
89506
89507   jresult = (void *)result;
89508   return jresult;
89509 }
89510
89511
89512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
89513   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89514   int arg2 ;
89515   Dali::Actor *arg3 = 0 ;
89516
89517   arg1 = (std::vector< Dali::Actor > *)jarg1;
89518   arg2 = (int)jarg2;
89519   arg3 = (Dali::Actor *)jarg3;
89520   if (!arg3) {
89521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89522     return ;
89523   }
89524   {
89525     try {
89526       try {
89527         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
89528       }
89529       catch(std::out_of_range &_e) {
89530         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89531         return ;
89532       }
89533
89534     } catch (std::out_of_range& e) {
89535       {
89536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89537       };
89538     } catch (std::exception& e) {
89539       {
89540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89541       };
89542     } catch (Dali::DaliException e) {
89543       {
89544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89545       };
89546     } catch (...) {
89547       {
89548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89549       };
89550     }
89551   }
89552
89553 }
89554
89555
89556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
89557   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89558   int arg2 ;
89559   std::vector< Dali::Actor > *arg3 = 0 ;
89560
89561   arg1 = (std::vector< Dali::Actor > *)jarg1;
89562   arg2 = (int)jarg2;
89563   arg3 = (std::vector< Dali::Actor > *)jarg3;
89564   if (!arg3) {
89565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89566     return ;
89567   }
89568   {
89569     try {
89570       try {
89571         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89572       }
89573       catch(std::out_of_range &_e) {
89574         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89575         return ;
89576       }
89577
89578     } catch (std::out_of_range& e) {
89579       {
89580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89581       };
89582     } catch (std::exception& e) {
89583       {
89584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89585       };
89586     } catch (Dali::DaliException e) {
89587       {
89588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89589       };
89590     } catch (...) {
89591       {
89592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89593       };
89594     }
89595   }
89596
89597 }
89598
89599
89600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
89601   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89602   int arg2 ;
89603
89604   arg1 = (std::vector< Dali::Actor > *)jarg1;
89605   arg2 = (int)jarg2;
89606   {
89607     try {
89608       try {
89609         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
89610       }
89611       catch(std::out_of_range &_e) {
89612         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89613         return ;
89614       }
89615
89616     } catch (std::out_of_range& e) {
89617       {
89618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89619       };
89620     } catch (std::exception& e) {
89621       {
89622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89623       };
89624     } catch (Dali::DaliException e) {
89625       {
89626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89627       };
89628     } catch (...) {
89629       {
89630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89631       };
89632     }
89633   }
89634
89635 }
89636
89637
89638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
89639   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89640   int arg2 ;
89641   int arg3 ;
89642
89643   arg1 = (std::vector< Dali::Actor > *)jarg1;
89644   arg2 = (int)jarg2;
89645   arg3 = (int)jarg3;
89646   {
89647     try {
89648       try {
89649         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
89650       }
89651       catch(std::out_of_range &_e) {
89652         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89653         return ;
89654       }
89655       catch(std::invalid_argument &_e) {
89656         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89657         return ;
89658       }
89659
89660     } catch (std::out_of_range& e) {
89661       {
89662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89663       };
89664     } catch (std::exception& e) {
89665       {
89666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89667       };
89668     } catch (Dali::DaliException e) {
89669       {
89670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89671       };
89672     } catch (...) {
89673       {
89674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89675       };
89676     }
89677   }
89678
89679 }
89680
89681
89682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
89683   void * jresult ;
89684   Dali::Actor *arg1 = 0 ;
89685   int arg2 ;
89686   std::vector< Dali::Actor > *result = 0 ;
89687
89688   arg1 = (Dali::Actor *)jarg1;
89689   if (!arg1) {
89690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89691     return 0;
89692   }
89693   arg2 = (int)jarg2;
89694   {
89695     try {
89696       try {
89697         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
89698       }
89699       catch(std::out_of_range &_e) {
89700         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89701         return 0;
89702       }
89703
89704     } catch (std::out_of_range& e) {
89705       {
89706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89707       };
89708     } catch (std::exception& e) {
89709       {
89710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89711       };
89712     } catch (Dali::DaliException e) {
89713       {
89714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89715       };
89716     } catch (...) {
89717       {
89718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89719       };
89720     }
89721   }
89722
89723   jresult = (void *)result;
89724   return jresult;
89725 }
89726
89727
89728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
89729   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89730
89731   arg1 = (std::vector< Dali::Actor > *)jarg1;
89732   {
89733     try {
89734       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
89735     } catch (std::out_of_range& e) {
89736       {
89737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89738       };
89739     } catch (std::exception& e) {
89740       {
89741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89742       };
89743     } catch (Dali::DaliException e) {
89744       {
89745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89746       };
89747     } catch (...) {
89748       {
89749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89750       };
89751     }
89752   }
89753
89754 }
89755
89756
89757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89758   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89759   int arg2 ;
89760   int arg3 ;
89761
89762   arg1 = (std::vector< Dali::Actor > *)jarg1;
89763   arg2 = (int)jarg2;
89764   arg3 = (int)jarg3;
89765   {
89766     try {
89767       try {
89768         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89769       }
89770       catch(std::out_of_range &_e) {
89771         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89772         return ;
89773       }
89774       catch(std::invalid_argument &_e) {
89775         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89776         return ;
89777       }
89778
89779     } catch (std::out_of_range& e) {
89780       {
89781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89782       };
89783     } catch (std::exception& e) {
89784       {
89785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89786       };
89787     } catch (Dali::DaliException e) {
89788       {
89789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89790       };
89791     } catch (...) {
89792       {
89793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89794       };
89795     }
89796   }
89797
89798 }
89799
89800
89801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89802   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89803   int arg2 ;
89804   std::vector< Dali::Actor > *arg3 = 0 ;
89805
89806   arg1 = (std::vector< Dali::Actor > *)jarg1;
89807   arg2 = (int)jarg2;
89808   arg3 = (std::vector< Dali::Actor > *)jarg3;
89809   if (!arg3) {
89810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89811     return ;
89812   }
89813   {
89814     try {
89815       try {
89816         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89817       }
89818       catch(std::out_of_range &_e) {
89819         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89820         return ;
89821       }
89822
89823     } catch (std::out_of_range& e) {
89824       {
89825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89826       };
89827     } catch (std::exception& e) {
89828       {
89829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89830       };
89831     } catch (Dali::DaliException e) {
89832       {
89833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89834       };
89835     } catch (...) {
89836       {
89837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89838       };
89839     }
89840   }
89841
89842 }
89843
89844
89845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
89846   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89847
89848   arg1 = (std::vector< Dali::Actor > *)jarg1;
89849   {
89850     try {
89851       delete arg1;
89852     } catch (std::out_of_range& e) {
89853       {
89854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89855       };
89856     } catch (std::exception& e) {
89857       {
89858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89859       };
89860     } catch (Dali::DaliException e) {
89861       {
89862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89863       };
89864     } catch (...) {
89865       {
89866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89867       };
89868     }
89869   }
89870
89871 }
89872
89873
89874 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
89875   unsigned int jresult ;
89876   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89877   bool result;
89878
89879   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89880   {
89881     try {
89882       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89883     } catch (std::out_of_range& e) {
89884       {
89885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89886       };
89887     } catch (std::exception& e) {
89888       {
89889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89890       };
89891     } catch (Dali::DaliException e) {
89892       {
89893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89894       };
89895     } catch (...) {
89896       {
89897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89898       };
89899     }
89900   }
89901
89902   jresult = result;
89903   return jresult;
89904 }
89905
89906
89907 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
89908   unsigned long jresult ;
89909   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89910   std::size_t result;
89911
89912   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89913   {
89914     try {
89915       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89916     } catch (std::out_of_range& e) {
89917       {
89918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89919       };
89920     } catch (std::exception& e) {
89921       {
89922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89923       };
89924     } catch (Dali::DaliException e) {
89925       {
89926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89927       };
89928     } catch (...) {
89929       {
89930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89931       };
89932     }
89933   }
89934
89935   jresult = (unsigned long)result;
89936   return jresult;
89937 }
89938
89939
89940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
89941   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89942   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
89943
89944   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89945   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
89946   {
89947     try {
89948       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
89949     } catch (std::out_of_range& e) {
89950       {
89951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89952       };
89953     } catch (std::exception& e) {
89954       {
89955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89956       };
89957     } catch (Dali::DaliException e) {
89958       {
89959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89960       };
89961     } catch (...) {
89962       {
89963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89964       };
89965     }
89966   }
89967
89968 }
89969
89970
89971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
89972   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89973   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
89974
89975   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89976   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
89977   {
89978     try {
89979       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
89980     } catch (std::out_of_range& e) {
89981       {
89982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89983       };
89984     } catch (std::exception& e) {
89985       {
89986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89987       };
89988     } catch (Dali::DaliException e) {
89989       {
89990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89991       };
89992     } catch (...) {
89993       {
89994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89995       };
89996     }
89997   }
89998
89999 }
90000
90001
90002 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
90003   unsigned int jresult ;
90004   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90005   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
90006   bool result;
90007
90008   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90009   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
90010   if (!arg2) {
90011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
90012     return 0;
90013   }
90014   {
90015     try {
90016       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
90017     } catch (std::out_of_range& e) {
90018       {
90019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90020       };
90021     } catch (std::exception& e) {
90022       {
90023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90024       };
90025     } catch (Dali::DaliException e) {
90026       {
90027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90028       };
90029     } catch (...) {
90030       {
90031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90032       };
90033     }
90034   }
90035
90036   jresult = result;
90037   return jresult;
90038 }
90039
90040
90041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
90042   void * jresult ;
90043   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
90044
90045   {
90046     try {
90047       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
90048     } catch (std::out_of_range& e) {
90049       {
90050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90051       };
90052     } catch (std::exception& e) {
90053       {
90054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90055       };
90056     } catch (Dali::DaliException e) {
90057       {
90058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90059       };
90060     } catch (...) {
90061       {
90062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90063       };
90064     }
90065   }
90066
90067   jresult = (void *)result;
90068   return jresult;
90069 }
90070
90071
90072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
90073   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90074
90075   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90076   {
90077     try {
90078       delete arg1;
90079     } catch (std::out_of_range& e) {
90080       {
90081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90082       };
90083     } catch (std::exception& e) {
90084       {
90085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90086       };
90087     } catch (Dali::DaliException e) {
90088       {
90089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90090       };
90091     } catch (...) {
90092       {
90093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90094       };
90095     }
90096   }
90097
90098 }
90099
90100
90101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
90102   unsigned int jresult ;
90103   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90104   bool result;
90105
90106   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90107   {
90108     try {
90109       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);
90110     } catch (std::out_of_range& e) {
90111       {
90112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90113       };
90114     } catch (std::exception& e) {
90115       {
90116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90117       };
90118     } catch (Dali::DaliException e) {
90119       {
90120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90121       };
90122     } catch (...) {
90123       {
90124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90125       };
90126     }
90127   }
90128
90129   jresult = result;
90130   return jresult;
90131 }
90132
90133
90134 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
90135   unsigned long jresult ;
90136   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90137   std::size_t result;
90138
90139   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90140   {
90141     try {
90142       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);
90143     } catch (std::out_of_range& e) {
90144       {
90145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90146       };
90147     } catch (std::exception& e) {
90148       {
90149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90150       };
90151     } catch (Dali::DaliException e) {
90152       {
90153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90154       };
90155     } catch (...) {
90156       {
90157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90158       };
90159     }
90160   }
90161
90162   jresult = (unsigned long)result;
90163   return jresult;
90164 }
90165
90166
90167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
90168   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90169   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90170
90171   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90172   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90173   {
90174     try {
90175       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
90176     } catch (std::out_of_range& e) {
90177       {
90178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90179       };
90180     } catch (std::exception& e) {
90181       {
90182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90183       };
90184     } catch (Dali::DaliException e) {
90185       {
90186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90187       };
90188     } catch (...) {
90189       {
90190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90191       };
90192     }
90193   }
90194
90195 }
90196
90197
90198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
90199   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90200   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90201
90202   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90203   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90204   {
90205     try {
90206       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
90207     } catch (std::out_of_range& e) {
90208       {
90209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90210       };
90211     } catch (std::exception& e) {
90212       {
90213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90214       };
90215     } catch (Dali::DaliException e) {
90216       {
90217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90218       };
90219     } catch (...) {
90220       {
90221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90222       };
90223     }
90224   }
90225
90226 }
90227
90228
90229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90230   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90231   Dali::Actor arg2 ;
90232   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
90233   Dali::Actor *argp2 ;
90234
90235   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90236   argp2 = (Dali::Actor *)jarg2;
90237   if (!argp2) {
90238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90239     return ;
90240   }
90241   arg2 = *argp2;
90242   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
90243   {
90244     try {
90245       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
90246     } catch (std::out_of_range& e) {
90247       {
90248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90249       };
90250     } catch (std::exception& e) {
90251       {
90252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90253       };
90254     } catch (Dali::DaliException e) {
90255       {
90256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90257       };
90258     } catch (...) {
90259       {
90260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90261       };
90262     }
90263   }
90264
90265 }
90266
90267
90268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
90269   void * jresult ;
90270   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
90271
90272   {
90273     try {
90274       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
90275     } catch (std::out_of_range& e) {
90276       {
90277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90278       };
90279     } catch (std::exception& e) {
90280       {
90281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90282       };
90283     } catch (Dali::DaliException e) {
90284       {
90285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90286       };
90287     } catch (...) {
90288       {
90289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90290       };
90291     }
90292   }
90293
90294   jresult = (void *)result;
90295   return jresult;
90296 }
90297
90298
90299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
90300   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90301
90302   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90303   {
90304     try {
90305       delete arg1;
90306     } catch (std::out_of_range& e) {
90307       {
90308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90309       };
90310     } catch (std::exception& e) {
90311       {
90312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90313       };
90314     } catch (Dali::DaliException e) {
90315       {
90316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90317       };
90318     } catch (...) {
90319       {
90320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90321       };
90322     }
90323   }
90324
90325 }
90326
90327
90328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
90329   unsigned int jresult ;
90330   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90331   bool result;
90332
90333   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90334   {
90335     try {
90336       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90337     } catch (std::out_of_range& e) {
90338       {
90339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90340       };
90341     } catch (std::exception& e) {
90342       {
90343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90344       };
90345     } catch (Dali::DaliException e) {
90346       {
90347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90348       };
90349     } catch (...) {
90350       {
90351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90352       };
90353     }
90354   }
90355
90356   jresult = result;
90357   return jresult;
90358 }
90359
90360
90361 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
90362   unsigned long jresult ;
90363   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90364   std::size_t result;
90365
90366   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90367   {
90368     try {
90369       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90370     } catch (std::out_of_range& e) {
90371       {
90372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90373       };
90374     } catch (std::exception& e) {
90375       {
90376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90377       };
90378     } catch (Dali::DaliException e) {
90379       {
90380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90381       };
90382     } catch (...) {
90383       {
90384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90385       };
90386     }
90387   }
90388
90389   jresult = (unsigned long)result;
90390   return jresult;
90391 }
90392
90393
90394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
90395   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90396   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90397
90398   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90399   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90400   {
90401     try {
90402       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
90403     } catch (std::out_of_range& e) {
90404       {
90405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90406       };
90407     } catch (std::exception& e) {
90408       {
90409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90410       };
90411     } catch (Dali::DaliException e) {
90412       {
90413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90414       };
90415     } catch (...) {
90416       {
90417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90418       };
90419     }
90420   }
90421
90422 }
90423
90424
90425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90426   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90427   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90428
90429   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90430   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90431   {
90432     try {
90433       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
90434     } catch (std::out_of_range& e) {
90435       {
90436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90437       };
90438     } catch (std::exception& e) {
90439       {
90440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90441       };
90442     } catch (Dali::DaliException e) {
90443       {
90444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90445       };
90446     } catch (...) {
90447       {
90448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90449       };
90450     }
90451   }
90452
90453 }
90454
90455
90456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
90457   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90458   Dali::Actor arg2 ;
90459   Dali::Actor arg3 ;
90460   Dali::Actor *argp2 ;
90461   Dali::Actor *argp3 ;
90462
90463   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90464   argp2 = (Dali::Actor *)jarg2;
90465   if (!argp2) {
90466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90467     return ;
90468   }
90469   arg2 = *argp2;
90470   argp3 = (Dali::Actor *)jarg3;
90471   if (!argp3) {
90472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90473     return ;
90474   }
90475   arg3 = *argp3;
90476   {
90477     try {
90478       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
90479     } catch (std::out_of_range& e) {
90480       {
90481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90482       };
90483     } catch (std::exception& e) {
90484       {
90485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90486       };
90487     } catch (Dali::DaliException e) {
90488       {
90489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90490       };
90491     } catch (...) {
90492       {
90493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90494       };
90495     }
90496   }
90497
90498 }
90499
90500
90501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
90502   void * jresult ;
90503   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
90504
90505   {
90506     try {
90507       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
90508     } catch (std::out_of_range& e) {
90509       {
90510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90511       };
90512     } catch (std::exception& e) {
90513       {
90514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90515       };
90516     } catch (Dali::DaliException e) {
90517       {
90518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90519       };
90520     } catch (...) {
90521       {
90522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90523       };
90524     }
90525   }
90526
90527   jresult = (void *)result;
90528   return jresult;
90529 }
90530
90531
90532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
90533   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90534
90535   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90536   {
90537     try {
90538       delete arg1;
90539     } catch (std::out_of_range& e) {
90540       {
90541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90542       };
90543     } catch (std::exception& e) {
90544       {
90545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90546       };
90547     } catch (Dali::DaliException e) {
90548       {
90549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90550       };
90551     } catch (...) {
90552       {
90553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90554       };
90555     }
90556   }
90557
90558 }
90559
90560
90561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
90562   unsigned int jresult ;
90563   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90564   bool result;
90565
90566   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90567   {
90568     try {
90569       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
90570     } catch (std::out_of_range& e) {
90571       {
90572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90573       };
90574     } catch (std::exception& e) {
90575       {
90576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90577       };
90578     } catch (Dali::DaliException e) {
90579       {
90580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90581       };
90582     } catch (...) {
90583       {
90584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90585       };
90586     }
90587   }
90588
90589   jresult = result;
90590   return jresult;
90591 }
90592
90593
90594 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
90595   unsigned long jresult ;
90596   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90597   std::size_t result;
90598
90599   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90600   {
90601     try {
90602       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
90603     } catch (std::out_of_range& e) {
90604       {
90605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90606       };
90607     } catch (std::exception& e) {
90608       {
90609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90610       };
90611     } catch (Dali::DaliException e) {
90612       {
90613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90614       };
90615     } catch (...) {
90616       {
90617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90618       };
90619     }
90620   }
90621
90622   jresult = (unsigned long)result;
90623   return jresult;
90624 }
90625
90626
90627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
90628   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90629   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
90630
90631   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90632   arg2 = (void (*)(Dali::Actor,bool))jarg2;
90633   {
90634     try {
90635       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
90636     } catch (std::out_of_range& e) {
90637       {
90638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90639       };
90640     } catch (std::exception& e) {
90641       {
90642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90643       };
90644     } catch (Dali::DaliException e) {
90645       {
90646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90647       };
90648     } catch (...) {
90649       {
90650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90651       };
90652     }
90653   }
90654
90655 }
90656
90657
90658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90659   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90660   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
90661
90662   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90663   arg2 = (void (*)(Dali::Actor,bool))jarg2;
90664   {
90665     try {
90666       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
90667     } catch (std::out_of_range& e) {
90668       {
90669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90670       };
90671     } catch (std::exception& e) {
90672       {
90673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90674       };
90675     } catch (Dali::DaliException e) {
90676       {
90677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90678       };
90679     } catch (...) {
90680       {
90681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90682       };
90683     }
90684   }
90685
90686 }
90687
90688
90689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
90690   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90691   Dali::Actor arg2 ;
90692   bool arg3 ;
90693   Dali::Actor *argp2 ;
90694
90695   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90696   argp2 = (Dali::Actor *)jarg2;
90697   if (!argp2) {
90698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90699     return ;
90700   }
90701   arg2 = *argp2;
90702   arg3 = jarg3 ? true : false;
90703   {
90704     try {
90705       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
90706     } catch (std::out_of_range& e) {
90707       {
90708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90709       };
90710     } catch (std::exception& e) {
90711       {
90712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90713       };
90714     } catch (Dali::DaliException e) {
90715       {
90716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90717       };
90718     } catch (...) {
90719       {
90720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90721       };
90722     }
90723   }
90724
90725 }
90726
90727
90728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
90729   void * jresult ;
90730   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
90731
90732   {
90733     try {
90734       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
90735     } catch (std::out_of_range& e) {
90736       {
90737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90738       };
90739     } catch (std::exception& e) {
90740       {
90741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90742       };
90743     } catch (Dali::DaliException e) {
90744       {
90745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90746       };
90747     } catch (...) {
90748       {
90749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90750       };
90751     }
90752   }
90753
90754   jresult = (void *)result;
90755   return jresult;
90756 }
90757
90758
90759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
90760   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90761
90762   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90763   {
90764     try {
90765       delete arg1;
90766     } catch (std::out_of_range& e) {
90767       {
90768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90769       };
90770     } catch (std::exception& e) {
90771       {
90772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90773       };
90774     } catch (Dali::DaliException e) {
90775       {
90776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90777       };
90778     } catch (...) {
90779       {
90780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90781       };
90782     }
90783   }
90784
90785 }
90786
90787
90788 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
90789   unsigned int jresult ;
90790   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90791   bool result;
90792
90793   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90794   {
90795     try {
90796       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);
90797     } catch (std::out_of_range& e) {
90798       {
90799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90800       };
90801     } catch (std::exception& e) {
90802       {
90803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90804       };
90805     } catch (Dali::DaliException e) {
90806       {
90807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90808       };
90809     } catch (...) {
90810       {
90811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90812       };
90813     }
90814   }
90815
90816   jresult = result;
90817   return jresult;
90818 }
90819
90820
90821 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
90822   unsigned long jresult ;
90823   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90824   std::size_t result;
90825
90826   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90827   {
90828     try {
90829       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);
90830     } catch (std::out_of_range& e) {
90831       {
90832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90833       };
90834     } catch (std::exception& e) {
90835       {
90836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90837       };
90838     } catch (Dali::DaliException e) {
90839       {
90840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90841       };
90842     } catch (...) {
90843       {
90844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90845       };
90846     }
90847   }
90848
90849   jresult = (unsigned long)result;
90850   return jresult;
90851 }
90852
90853
90854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
90855   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90856   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
90857
90858   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90859   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
90860   {
90861     try {
90862       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
90863     } catch (std::out_of_range& e) {
90864       {
90865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90866       };
90867     } catch (std::exception& e) {
90868       {
90869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90870       };
90871     } catch (Dali::DaliException e) {
90872       {
90873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90874       };
90875     } catch (...) {
90876       {
90877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90878       };
90879     }
90880   }
90881
90882 }
90883
90884
90885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90886   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90887   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
90888
90889   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90890   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
90891   {
90892     try {
90893       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
90894     } catch (std::out_of_range& e) {
90895       {
90896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90897       };
90898     } catch (std::exception& e) {
90899       {
90900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90901       };
90902     } catch (Dali::DaliException e) {
90903       {
90904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90905       };
90906     } catch (...) {
90907       {
90908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90909       };
90910     }
90911   }
90912
90913 }
90914
90915
90916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90917   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90918   Dali::Toolkit::StyleManager arg2 ;
90919   Dali::StyleChange::Type arg3 ;
90920   Dali::Toolkit::StyleManager *argp2 ;
90921
90922   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90923   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
90924   if (!argp2) {
90925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
90926     return ;
90927   }
90928   arg2 = *argp2;
90929   arg3 = (Dali::StyleChange::Type)jarg3;
90930   {
90931     try {
90932       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
90933     } catch (std::out_of_range& e) {
90934       {
90935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90936       };
90937     } catch (std::exception& e) {
90938       {
90939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90940       };
90941     } catch (Dali::DaliException e) {
90942       {
90943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90944       };
90945     } catch (...) {
90946       {
90947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90948       };
90949     }
90950   }
90951
90952 }
90953
90954
90955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
90956   void * jresult ;
90957   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
90958
90959   {
90960     try {
90961       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
90962     } catch (std::out_of_range& e) {
90963       {
90964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90965       };
90966     } catch (std::exception& e) {
90967       {
90968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90969       };
90970     } catch (Dali::DaliException e) {
90971       {
90972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90973       };
90974     } catch (...) {
90975       {
90976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90977       };
90978     }
90979   }
90980
90981   jresult = (void *)result;
90982   return jresult;
90983 }
90984
90985
90986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
90987   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90988
90989   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90990   {
90991     try {
90992       delete arg1;
90993     } catch (std::out_of_range& e) {
90994       {
90995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90996       };
90997     } catch (std::exception& e) {
90998       {
90999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91000       };
91001     } catch (Dali::DaliException e) {
91002       {
91003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91004       };
91005     } catch (...) {
91006       {
91007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91008       };
91009     }
91010   }
91011
91012 }
91013
91014
91015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
91016   unsigned int jresult ;
91017   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91018   bool result;
91019
91020   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91021   {
91022     try {
91023       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
91024     } catch (std::out_of_range& e) {
91025       {
91026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91027       };
91028     } catch (std::exception& e) {
91029       {
91030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91031       };
91032     } catch (Dali::DaliException e) {
91033       {
91034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91035       };
91036     } catch (...) {
91037       {
91038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91039       };
91040     }
91041   }
91042
91043   jresult = result;
91044   return jresult;
91045 }
91046
91047
91048 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
91049   unsigned long jresult ;
91050   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91051   std::size_t result;
91052
91053   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91054   {
91055     try {
91056       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
91057     } catch (std::out_of_range& e) {
91058       {
91059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91060       };
91061     } catch (std::exception& e) {
91062       {
91063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91064       };
91065     } catch (Dali::DaliException e) {
91066       {
91067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91068       };
91069     } catch (...) {
91070       {
91071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91072       };
91073     }
91074   }
91075
91076   jresult = (unsigned long)result;
91077   return jresult;
91078 }
91079
91080
91081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
91082   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91083   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91084
91085   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91086   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91087   {
91088     try {
91089       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
91090     } catch (std::out_of_range& e) {
91091       {
91092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91093       };
91094     } catch (std::exception& e) {
91095       {
91096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91097       };
91098     } catch (Dali::DaliException e) {
91099       {
91100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91101       };
91102     } catch (...) {
91103       {
91104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91105       };
91106     }
91107   }
91108
91109 }
91110
91111
91112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
91113   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91114   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91115
91116   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91117   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91118   {
91119     try {
91120       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
91121     } catch (std::out_of_range& e) {
91122       {
91123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91124       };
91125     } catch (std::exception& e) {
91126       {
91127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91128       };
91129     } catch (Dali::DaliException e) {
91130       {
91131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91132       };
91133     } catch (...) {
91134       {
91135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91136       };
91137     }
91138   }
91139
91140 }
91141
91142
91143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
91144   unsigned int jresult ;
91145   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91146   Dali::Toolkit::Button arg2 ;
91147   Dali::Toolkit::Button *argp2 ;
91148   bool result;
91149
91150   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91151   argp2 = (Dali::Toolkit::Button *)jarg2;
91152   if (!argp2) {
91153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
91154     return 0;
91155   }
91156   arg2 = *argp2;
91157   {
91158     try {
91159       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
91160     } catch (std::out_of_range& e) {
91161       {
91162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91163       };
91164     } catch (std::exception& e) {
91165       {
91166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91167       };
91168     } catch (Dali::DaliException e) {
91169       {
91170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91171       };
91172     } catch (...) {
91173       {
91174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91175       };
91176     }
91177   }
91178
91179   jresult = result;
91180   return jresult;
91181 }
91182
91183
91184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
91185   void * jresult ;
91186   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
91187
91188   {
91189     try {
91190       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
91191     } catch (std::out_of_range& e) {
91192       {
91193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91194       };
91195     } catch (std::exception& e) {
91196       {
91197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91198       };
91199     } catch (Dali::DaliException e) {
91200       {
91201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91202       };
91203     } catch (...) {
91204       {
91205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91206       };
91207     }
91208   }
91209
91210   jresult = (void *)result;
91211   return jresult;
91212 }
91213
91214
91215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
91216   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91217
91218   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91219   {
91220     try {
91221       delete arg1;
91222     } catch (std::out_of_range& e) {
91223       {
91224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91225       };
91226     } catch (std::exception& e) {
91227       {
91228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91229       };
91230     } catch (Dali::DaliException e) {
91231       {
91232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91233       };
91234     } catch (...) {
91235       {
91236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91237       };
91238     }
91239   }
91240
91241 }
91242
91243
91244 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
91245   unsigned int jresult ;
91246   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91247   bool result;
91248
91249   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91250   {
91251     try {
91252       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91253     } catch (std::out_of_range& e) {
91254       {
91255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91256       };
91257     } catch (std::exception& e) {
91258       {
91259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91260       };
91261     } catch (Dali::DaliException e) {
91262       {
91263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91264       };
91265     } catch (...) {
91266       {
91267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91268       };
91269     }
91270   }
91271
91272   jresult = result;
91273   return jresult;
91274 }
91275
91276
91277 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
91278   unsigned long jresult ;
91279   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91280   std::size_t result;
91281
91282   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91283   {
91284     try {
91285       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91286     } catch (std::out_of_range& e) {
91287       {
91288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91289       };
91290     } catch (std::exception& e) {
91291       {
91292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91293       };
91294     } catch (Dali::DaliException e) {
91295       {
91296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91297       };
91298     } catch (...) {
91299       {
91300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91301       };
91302     }
91303   }
91304
91305   jresult = (unsigned long)result;
91306   return jresult;
91307 }
91308
91309
91310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
91311   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91312   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91313
91314   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91315   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91316   {
91317     try {
91318       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
91319     } catch (std::out_of_range& e) {
91320       {
91321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91322       };
91323     } catch (std::exception& e) {
91324       {
91325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91326       };
91327     } catch (Dali::DaliException e) {
91328       {
91329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91330       };
91331     } catch (...) {
91332       {
91333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91334       };
91335     }
91336   }
91337
91338 }
91339
91340
91341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
91342   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91343   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91344
91345   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91346   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91347   {
91348     try {
91349       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
91350     } catch (std::out_of_range& e) {
91351       {
91352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91353       };
91354     } catch (std::exception& e) {
91355       {
91356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91357       };
91358     } catch (Dali::DaliException e) {
91359       {
91360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91361       };
91362     } catch (...) {
91363       {
91364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91365       };
91366     }
91367   }
91368
91369 }
91370
91371
91372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
91373   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91374   Dali::Toolkit::GaussianBlurView arg2 ;
91375   Dali::Toolkit::GaussianBlurView *argp2 ;
91376
91377   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91378   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
91379   if (!argp2) {
91380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
91381     return ;
91382   }
91383   arg2 = *argp2;
91384   {
91385     try {
91386       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
91387     } catch (std::out_of_range& e) {
91388       {
91389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91390       };
91391     } catch (std::exception& e) {
91392       {
91393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91394       };
91395     } catch (Dali::DaliException e) {
91396       {
91397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91398       };
91399     } catch (...) {
91400       {
91401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91402       };
91403     }
91404   }
91405
91406 }
91407
91408
91409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
91410   void * jresult ;
91411   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
91412
91413   {
91414     try {
91415       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
91416     } catch (std::out_of_range& e) {
91417       {
91418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91419       };
91420     } catch (std::exception& e) {
91421       {
91422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91423       };
91424     } catch (Dali::DaliException e) {
91425       {
91426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91427       };
91428     } catch (...) {
91429       {
91430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91431       };
91432     }
91433   }
91434
91435   jresult = (void *)result;
91436   return jresult;
91437 }
91438
91439
91440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
91441   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91442
91443   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91444   {
91445     try {
91446       delete arg1;
91447     } catch (std::out_of_range& e) {
91448       {
91449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91450       };
91451     } catch (std::exception& e) {
91452       {
91453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91454       };
91455     } catch (Dali::DaliException e) {
91456       {
91457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91458       };
91459     } catch (...) {
91460       {
91461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91462       };
91463     }
91464   }
91465
91466 }
91467
91468
91469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
91470   unsigned int jresult ;
91471   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91472   bool result;
91473
91474   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91475   {
91476     try {
91477       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);
91478     } catch (std::out_of_range& e) {
91479       {
91480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91481       };
91482     } catch (std::exception& e) {
91483       {
91484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91485       };
91486     } catch (Dali::DaliException e) {
91487       {
91488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91489       };
91490     } catch (...) {
91491       {
91492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91493       };
91494     }
91495   }
91496
91497   jresult = result;
91498   return jresult;
91499 }
91500
91501
91502 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
91503   unsigned long jresult ;
91504   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91505   std::size_t result;
91506
91507   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91508   {
91509     try {
91510       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);
91511     } catch (std::out_of_range& e) {
91512       {
91513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91514       };
91515     } catch (std::exception& e) {
91516       {
91517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91518       };
91519     } catch (Dali::DaliException e) {
91520       {
91521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91522       };
91523     } catch (...) {
91524       {
91525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91526       };
91527     }
91528   }
91529
91530   jresult = (unsigned long)result;
91531   return jresult;
91532 }
91533
91534
91535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
91536   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91537   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
91538
91539   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91540   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
91541   {
91542     try {
91543       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
91544     } catch (std::out_of_range& e) {
91545       {
91546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91547       };
91548     } catch (std::exception& e) {
91549       {
91550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91551       };
91552     } catch (Dali::DaliException e) {
91553       {
91554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91555       };
91556     } catch (...) {
91557       {
91558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91559       };
91560     }
91561   }
91562
91563 }
91564
91565
91566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
91567   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91568   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
91569
91570   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91571   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
91572   {
91573     try {
91574       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
91575     } catch (std::out_of_range& e) {
91576       {
91577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91578       };
91579     } catch (std::exception& e) {
91580       {
91581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91582       };
91583     } catch (Dali::DaliException e) {
91584       {
91585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91586       };
91587     } catch (...) {
91588       {
91589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91590       };
91591     }
91592   }
91593
91594 }
91595
91596
91597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
91598   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91599   Dali::Toolkit::PageTurnView arg2 ;
91600   unsigned int arg3 ;
91601   bool arg4 ;
91602   Dali::Toolkit::PageTurnView *argp2 ;
91603
91604   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91605   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
91606   if (!argp2) {
91607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
91608     return ;
91609   }
91610   arg2 = *argp2;
91611   arg3 = (unsigned int)jarg3;
91612   arg4 = jarg4 ? true : false;
91613   {
91614     try {
91615       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
91616     } catch (std::out_of_range& e) {
91617       {
91618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91619       };
91620     } catch (std::exception& e) {
91621       {
91622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91623       };
91624     } catch (Dali::DaliException e) {
91625       {
91626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91627       };
91628     } catch (...) {
91629       {
91630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91631       };
91632     }
91633   }
91634
91635 }
91636
91637
91638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
91639   void * jresult ;
91640   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
91641
91642   {
91643     try {
91644       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
91645     } catch (std::out_of_range& e) {
91646       {
91647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91648       };
91649     } catch (std::exception& e) {
91650       {
91651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91652       };
91653     } catch (Dali::DaliException e) {
91654       {
91655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91656       };
91657     } catch (...) {
91658       {
91659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91660       };
91661     }
91662   }
91663
91664   jresult = (void *)result;
91665   return jresult;
91666 }
91667
91668
91669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
91670   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91671
91672   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91673   {
91674     try {
91675       delete arg1;
91676     } catch (std::out_of_range& e) {
91677       {
91678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91679       };
91680     } catch (std::exception& e) {
91681       {
91682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91683       };
91684     } catch (Dali::DaliException e) {
91685       {
91686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91687       };
91688     } catch (...) {
91689       {
91690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91691       };
91692     }
91693   }
91694
91695 }
91696
91697
91698 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
91699   unsigned int jresult ;
91700   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91701   bool result;
91702
91703   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91704   {
91705     try {
91706       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
91707     } catch (std::out_of_range& e) {
91708       {
91709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91710       };
91711     } catch (std::exception& e) {
91712       {
91713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91714       };
91715     } catch (Dali::DaliException e) {
91716       {
91717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91718       };
91719     } catch (...) {
91720       {
91721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91722       };
91723     }
91724   }
91725
91726   jresult = result;
91727   return jresult;
91728 }
91729
91730
91731 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
91732   unsigned long jresult ;
91733   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91734   std::size_t result;
91735
91736   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91737   {
91738     try {
91739       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
91740     } catch (std::out_of_range& e) {
91741       {
91742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91743       };
91744     } catch (std::exception& e) {
91745       {
91746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91747       };
91748     } catch (Dali::DaliException e) {
91749       {
91750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91751       };
91752     } catch (...) {
91753       {
91754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91755       };
91756     }
91757   }
91758
91759   jresult = (unsigned long)result;
91760   return jresult;
91761 }
91762
91763
91764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
91765   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91766   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
91767
91768   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91769   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
91770   {
91771     try {
91772       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
91773     } catch (std::out_of_range& e) {
91774       {
91775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91776       };
91777     } catch (std::exception& e) {
91778       {
91779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91780       };
91781     } catch (Dali::DaliException e) {
91782       {
91783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91784       };
91785     } catch (...) {
91786       {
91787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91788       };
91789     }
91790   }
91791
91792 }
91793
91794
91795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
91796   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91797   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
91798
91799   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91800   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
91801   {
91802     try {
91803       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
91804     } catch (std::out_of_range& e) {
91805       {
91806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91807       };
91808     } catch (std::exception& e) {
91809       {
91810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91811       };
91812     } catch (Dali::DaliException e) {
91813       {
91814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91815       };
91816     } catch (...) {
91817       {
91818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91819       };
91820     }
91821   }
91822
91823 }
91824
91825
91826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
91827   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91828   Dali::Toolkit::PageTurnView arg2 ;
91829   Dali::Toolkit::PageTurnView *argp2 ;
91830
91831   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91832   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
91833   if (!argp2) {
91834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
91835     return ;
91836   }
91837   arg2 = *argp2;
91838   {
91839     try {
91840       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
91841     } catch (std::out_of_range& e) {
91842       {
91843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91844       };
91845     } catch (std::exception& e) {
91846       {
91847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91848       };
91849     } catch (Dali::DaliException e) {
91850       {
91851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91852       };
91853     } catch (...) {
91854       {
91855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91856       };
91857     }
91858   }
91859
91860 }
91861
91862
91863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
91864   void * jresult ;
91865   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
91866
91867   {
91868     try {
91869       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
91870     } catch (std::out_of_range& e) {
91871       {
91872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91873       };
91874     } catch (std::exception& e) {
91875       {
91876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91877       };
91878     } catch (Dali::DaliException e) {
91879       {
91880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91881       };
91882     } catch (...) {
91883       {
91884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91885       };
91886     }
91887   }
91888
91889   jresult = (void *)result;
91890   return jresult;
91891 }
91892
91893
91894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
91895   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91896
91897   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91898   {
91899     try {
91900       delete arg1;
91901     } catch (std::out_of_range& e) {
91902       {
91903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91904       };
91905     } catch (std::exception& e) {
91906       {
91907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91908       };
91909     } catch (Dali::DaliException e) {
91910       {
91911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91912       };
91913     } catch (...) {
91914       {
91915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91916       };
91917     }
91918   }
91919
91920 }
91921
91922
91923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
91924   unsigned int jresult ;
91925   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91926   bool result;
91927
91928   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91929   {
91930     try {
91931       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);
91932     } catch (std::out_of_range& e) {
91933       {
91934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91935       };
91936     } catch (std::exception& e) {
91937       {
91938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91939       };
91940     } catch (Dali::DaliException e) {
91941       {
91942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91943       };
91944     } catch (...) {
91945       {
91946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91947       };
91948     }
91949   }
91950
91951   jresult = result;
91952   return jresult;
91953 }
91954
91955
91956 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
91957   unsigned long jresult ;
91958   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91959   std::size_t result;
91960
91961   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91962   {
91963     try {
91964       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);
91965     } catch (std::out_of_range& e) {
91966       {
91967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91968       };
91969     } catch (std::exception& e) {
91970       {
91971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91972       };
91973     } catch (Dali::DaliException e) {
91974       {
91975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91976       };
91977     } catch (...) {
91978       {
91979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91980       };
91981     }
91982   }
91983
91984   jresult = (unsigned long)result;
91985   return jresult;
91986 }
91987
91988
91989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
91990   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91991   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
91992
91993   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91994   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
91995   {
91996     try {
91997       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
91998     } catch (std::out_of_range& e) {
91999       {
92000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92001       };
92002     } catch (std::exception& e) {
92003       {
92004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92005       };
92006     } catch (Dali::DaliException e) {
92007       {
92008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92009       };
92010     } catch (...) {
92011       {
92012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92013       };
92014     }
92015   }
92016
92017 }
92018
92019
92020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
92021   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92022   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
92023
92024   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92025   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
92026   {
92027     try {
92028       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
92029     } catch (std::out_of_range& e) {
92030       {
92031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92032       };
92033     } catch (std::exception& e) {
92034       {
92035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92036       };
92037     } catch (Dali::DaliException e) {
92038       {
92039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92040       };
92041     } catch (...) {
92042       {
92043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92044       };
92045     }
92046   }
92047
92048 }
92049
92050
92051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
92052   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92053   Dali::Toolkit::ProgressBar arg2 ;
92054   float arg3 ;
92055   float arg4 ;
92056   Dali::Toolkit::ProgressBar *argp2 ;
92057
92058   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92059   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
92060   if (!argp2) {
92061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
92062     return ;
92063   }
92064   arg2 = *argp2;
92065   arg3 = (float)jarg3;
92066   arg4 = (float)jarg4;
92067   {
92068     try {
92069       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
92070     } catch (std::out_of_range& e) {
92071       {
92072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92073       };
92074     } catch (std::exception& e) {
92075       {
92076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92077       };
92078     } catch (Dali::DaliException e) {
92079       {
92080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92081       };
92082     } catch (...) {
92083       {
92084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92085       };
92086     }
92087   }
92088
92089 }
92090
92091
92092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
92093   void * jresult ;
92094   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
92095
92096   {
92097     try {
92098       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
92099     } catch (std::out_of_range& e) {
92100       {
92101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92102       };
92103     } catch (std::exception& e) {
92104       {
92105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92106       };
92107     } catch (Dali::DaliException e) {
92108       {
92109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92110       };
92111     } catch (...) {
92112       {
92113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92114       };
92115     }
92116   }
92117
92118   jresult = (void *)result;
92119   return jresult;
92120 }
92121
92122
92123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
92124   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92125
92126   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92127   {
92128     try {
92129       delete arg1;
92130     } catch (std::out_of_range& e) {
92131       {
92132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92133       };
92134     } catch (std::exception& e) {
92135       {
92136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92137       };
92138     } catch (Dali::DaliException e) {
92139       {
92140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92141       };
92142     } catch (...) {
92143       {
92144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92145       };
92146     }
92147   }
92148
92149 }
92150
92151
92152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
92153   unsigned int jresult ;
92154   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92155   bool result;
92156
92157   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92158   {
92159     try {
92160       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);
92161     } catch (std::out_of_range& e) {
92162       {
92163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92164       };
92165     } catch (std::exception& e) {
92166       {
92167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92168       };
92169     } catch (Dali::DaliException e) {
92170       {
92171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92172       };
92173     } catch (...) {
92174       {
92175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92176       };
92177     }
92178   }
92179
92180   jresult = result;
92181   return jresult;
92182 }
92183
92184
92185 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
92186   unsigned long jresult ;
92187   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92188   std::size_t result;
92189
92190   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92191   {
92192     try {
92193       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);
92194     } catch (std::out_of_range& e) {
92195       {
92196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92197       };
92198     } catch (std::exception& e) {
92199       {
92200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92201       };
92202     } catch (Dali::DaliException e) {
92203       {
92204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92205       };
92206     } catch (...) {
92207       {
92208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92209       };
92210     }
92211   }
92212
92213   jresult = (unsigned long)result;
92214   return jresult;
92215 }
92216
92217
92218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
92219   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92220   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92221
92222   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92223   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92224   {
92225     try {
92226       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92227     } catch (std::out_of_range& e) {
92228       {
92229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92230       };
92231     } catch (std::exception& e) {
92232       {
92233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92234       };
92235     } catch (Dali::DaliException e) {
92236       {
92237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92238       };
92239     } catch (...) {
92240       {
92241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92242       };
92243     }
92244   }
92245
92246 }
92247
92248
92249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
92250   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92251   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92252
92253   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92254   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92255   {
92256     try {
92257       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92258     } catch (std::out_of_range& e) {
92259       {
92260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92261       };
92262     } catch (std::exception& e) {
92263       {
92264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92265       };
92266     } catch (Dali::DaliException e) {
92267       {
92268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92269       };
92270     } catch (...) {
92271       {
92272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92273       };
92274     }
92275   }
92276
92277 }
92278
92279
92280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
92281   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92282   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
92283
92284   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92285   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
92286   if (!arg2) {
92287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
92288     return ;
92289   }
92290   {
92291     try {
92292       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
92293     } catch (std::out_of_range& e) {
92294       {
92295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92296       };
92297     } catch (std::exception& e) {
92298       {
92299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92300       };
92301     } catch (Dali::DaliException e) {
92302       {
92303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92304       };
92305     } catch (...) {
92306       {
92307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92308       };
92309     }
92310   }
92311
92312 }
92313
92314
92315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
92316   void * jresult ;
92317   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
92318
92319   {
92320     try {
92321       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
92322     } catch (std::out_of_range& e) {
92323       {
92324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92325       };
92326     } catch (std::exception& e) {
92327       {
92328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92329       };
92330     } catch (Dali::DaliException e) {
92331       {
92332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92333       };
92334     } catch (...) {
92335       {
92336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92337       };
92338     }
92339   }
92340
92341   jresult = (void *)result;
92342   return jresult;
92343 }
92344
92345
92346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
92347   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92348
92349   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92350   {
92351     try {
92352       delete arg1;
92353     } catch (std::out_of_range& e) {
92354       {
92355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92356       };
92357     } catch (std::exception& e) {
92358       {
92359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92360       };
92361     } catch (Dali::DaliException e) {
92362       {
92363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92364       };
92365     } catch (...) {
92366       {
92367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92368       };
92369     }
92370   }
92371
92372 }
92373
92374
92375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
92376   unsigned int jresult ;
92377   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92378   bool result;
92379
92380   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92381   {
92382     try {
92383       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92384     } catch (std::out_of_range& e) {
92385       {
92386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92387       };
92388     } catch (std::exception& e) {
92389       {
92390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92391       };
92392     } catch (Dali::DaliException e) {
92393       {
92394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92395       };
92396     } catch (...) {
92397       {
92398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92399       };
92400     }
92401   }
92402
92403   jresult = result;
92404   return jresult;
92405 }
92406
92407
92408 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
92409   unsigned long jresult ;
92410   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92411   std::size_t result;
92412
92413   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92414   {
92415     try {
92416       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92417     } catch (std::out_of_range& e) {
92418       {
92419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92420       };
92421     } catch (std::exception& e) {
92422       {
92423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92424       };
92425     } catch (Dali::DaliException e) {
92426       {
92427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92428       };
92429     } catch (...) {
92430       {
92431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92432       };
92433     }
92434   }
92435
92436   jresult = (unsigned long)result;
92437   return jresult;
92438 }
92439
92440
92441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
92442   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92443   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92444
92445   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92446   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92447   {
92448     try {
92449       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92450     } catch (std::out_of_range& e) {
92451       {
92452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92453       };
92454     } catch (std::exception& e) {
92455       {
92456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92457       };
92458     } catch (Dali::DaliException e) {
92459       {
92460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92461       };
92462     } catch (...) {
92463       {
92464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92465       };
92466     }
92467   }
92468
92469 }
92470
92471
92472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
92473   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92474   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92475
92476   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92477   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92478   {
92479     try {
92480       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92481     } catch (std::out_of_range& e) {
92482       {
92483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92484       };
92485     } catch (std::exception& e) {
92486       {
92487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92488       };
92489     } catch (Dali::DaliException e) {
92490       {
92491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92492       };
92493     } catch (...) {
92494       {
92495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92496       };
92497     }
92498   }
92499
92500 }
92501
92502
92503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
92504   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92505   Dali::Vector2 *arg2 = 0 ;
92506
92507   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92508   arg2 = (Dali::Vector2 *)jarg2;
92509   if (!arg2) {
92510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
92511     return ;
92512   }
92513   {
92514     try {
92515       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
92516     } catch (std::out_of_range& e) {
92517       {
92518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92519       };
92520     } catch (std::exception& e) {
92521       {
92522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92523       };
92524     } catch (Dali::DaliException e) {
92525       {
92526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92527       };
92528     } catch (...) {
92529       {
92530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92531       };
92532     }
92533   }
92534
92535 }
92536
92537
92538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
92539   void * jresult ;
92540   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
92541
92542   {
92543     try {
92544       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
92545     } catch (std::out_of_range& e) {
92546       {
92547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92548       };
92549     } catch (std::exception& e) {
92550       {
92551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92552       };
92553     } catch (Dali::DaliException e) {
92554       {
92555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92556       };
92557     } catch (...) {
92558       {
92559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92560       };
92561     }
92562   }
92563
92564   jresult = (void *)result;
92565   return jresult;
92566 }
92567
92568
92569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
92570   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92571
92572   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92573   {
92574     try {
92575       delete arg1;
92576     } catch (std::out_of_range& e) {
92577       {
92578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92579       };
92580     } catch (std::exception& e) {
92581       {
92582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92583       };
92584     } catch (Dali::DaliException e) {
92585       {
92586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92587       };
92588     } catch (...) {
92589       {
92590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92591       };
92592     }
92593   }
92594
92595 }
92596
92597
92598
92599 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
92600   unsigned int jresult ;
92601   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92602   bool result;
92603
92604   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92605   {
92606     try {
92607       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);
92608     } catch (std::out_of_range& e) {
92609       {
92610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92611       };
92612     } catch (std::exception& e) {
92613       {
92614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92615       };
92616     } catch (Dali::DaliException e) {
92617       {
92618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92619       };
92620     } catch (...) {
92621       {
92622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92623       };
92624     }
92625   }
92626
92627   jresult = result;
92628   return jresult;
92629 }
92630
92631
92632 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
92633   unsigned long jresult ;
92634   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92635   std::size_t result;
92636
92637   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92638   {
92639     try {
92640       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);
92641     } catch (std::out_of_range& e) {
92642       {
92643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92644       };
92645     } catch (std::exception& e) {
92646       {
92647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92648       };
92649     } catch (Dali::DaliException e) {
92650       {
92651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92652       };
92653     } catch (...) {
92654       {
92655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92656       };
92657     }
92658   }
92659
92660   jresult = (unsigned long)result;
92661   return jresult;
92662 }
92663
92664
92665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
92666   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92667   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92668
92669   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92670   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92671   {
92672     try {
92673       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92674     } catch (std::out_of_range& e) {
92675       {
92676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92677       };
92678     } catch (std::exception& e) {
92679       {
92680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92681       };
92682     } catch (Dali::DaliException e) {
92683       {
92684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92685       };
92686     } catch (...) {
92687       {
92688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92689       };
92690     }
92691   }
92692
92693 }
92694
92695
92696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
92697   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92698   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92699
92700   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92701   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92702   {
92703     try {
92704       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92705     } catch (std::out_of_range& e) {
92706       {
92707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92708       };
92709     } catch (std::exception& e) {
92710       {
92711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92712       };
92713     } catch (Dali::DaliException e) {
92714       {
92715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92716       };
92717     } catch (...) {
92718       {
92719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92720       };
92721     }
92722   }
92723
92724 }
92725
92726
92727 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
92728   unsigned int jresult ;
92729   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92730   Dali::Toolkit::Control arg2 ;
92731   Dali::KeyEvent *arg3 = 0 ;
92732   Dali::Toolkit::Control *argp2 ;
92733   bool result;
92734
92735   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92736   argp2 = (Dali::Toolkit::Control *)jarg2;
92737   if (!argp2) {
92738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
92739     return 0;
92740   }
92741   arg2 = *argp2;
92742   arg3 = (Dali::KeyEvent *)jarg3;
92743   if (!arg3) {
92744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
92745     return 0;
92746   }
92747   {
92748     try {
92749       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);
92750     } catch (std::out_of_range& e) {
92751       {
92752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92753       };
92754     } catch (std::exception& e) {
92755       {
92756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92757       };
92758     } catch (Dali::DaliException e) {
92759       {
92760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92761       };
92762     } catch (...) {
92763       {
92764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92765       };
92766     }
92767   }
92768
92769   jresult = result;
92770   return jresult;
92771 }
92772
92773
92774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
92775   void * jresult ;
92776   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
92777
92778   {
92779     try {
92780       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
92781     } catch (std::out_of_range& e) {
92782       {
92783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92784       };
92785     } catch (std::exception& e) {
92786       {
92787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92788       };
92789     } catch (Dali::DaliException e) {
92790       {
92791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92792       };
92793     } catch (...) {
92794       {
92795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92796       };
92797     }
92798   }
92799
92800   jresult = (void *)result;
92801   return jresult;
92802 }
92803
92804
92805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
92806   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92807
92808   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92809   {
92810     try {
92811       delete arg1;
92812     } catch (std::out_of_range& e) {
92813       {
92814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92815       };
92816     } catch (std::exception& e) {
92817       {
92818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92819       };
92820     } catch (Dali::DaliException e) {
92821       {
92822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92823       };
92824     } catch (...) {
92825       {
92826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92827       };
92828     }
92829   }
92830
92831 }
92832
92833
92834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
92835   unsigned int jresult ;
92836   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92837   bool result;
92838
92839   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92840   {
92841     try {
92842       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
92843     } catch (std::out_of_range& e) {
92844       {
92845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92846       };
92847     } catch (std::exception& e) {
92848       {
92849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92850       };
92851     } catch (Dali::DaliException e) {
92852       {
92853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92854       };
92855     } catch (...) {
92856       {
92857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92858       };
92859     }
92860   }
92861
92862   jresult = result;
92863   return jresult;
92864 }
92865
92866
92867 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
92868   unsigned long jresult ;
92869   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92870   std::size_t result;
92871
92872   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92873   {
92874     try {
92875       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
92876     } catch (std::out_of_range& e) {
92877       {
92878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92879       };
92880     } catch (std::exception& e) {
92881       {
92882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92883       };
92884     } catch (Dali::DaliException e) {
92885       {
92886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92887       };
92888     } catch (...) {
92889       {
92890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92891       };
92892     }
92893   }
92894
92895   jresult = (unsigned long)result;
92896   return jresult;
92897 }
92898
92899
92900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
92901   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92902   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
92903
92904   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92905   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
92906   {
92907     try {
92908       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
92909     } catch (std::out_of_range& e) {
92910       {
92911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92912       };
92913     } catch (std::exception& e) {
92914       {
92915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92916       };
92917     } catch (Dali::DaliException e) {
92918       {
92919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92920       };
92921     } catch (...) {
92922       {
92923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92924       };
92925     }
92926   }
92927
92928 }
92929
92930
92931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
92932   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92933   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
92934
92935   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92936   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
92937   {
92938     try {
92939       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
92940     } catch (std::out_of_range& e) {
92941       {
92942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92943       };
92944     } catch (std::exception& e) {
92945       {
92946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92947       };
92948     } catch (Dali::DaliException e) {
92949       {
92950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92951       };
92952     } catch (...) {
92953       {
92954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92955       };
92956     }
92957   }
92958
92959 }
92960
92961
92962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
92963   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92964   Dali::Toolkit::Control arg2 ;
92965   Dali::Toolkit::Control *argp2 ;
92966
92967   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92968   argp2 = (Dali::Toolkit::Control *)jarg2;
92969   if (!argp2) {
92970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
92971     return ;
92972   }
92973   arg2 = *argp2;
92974   {
92975     try {
92976       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
92977     } catch (std::out_of_range& e) {
92978       {
92979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92980       };
92981     } catch (std::exception& e) {
92982       {
92983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92984       };
92985     } catch (Dali::DaliException e) {
92986       {
92987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92988       };
92989     } catch (...) {
92990       {
92991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92992       };
92993     }
92994   }
92995
92996 }
92997
92998
92999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
93000   void * jresult ;
93001   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
93002
93003   {
93004     try {
93005       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
93006     } catch (std::out_of_range& e) {
93007       {
93008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93009       };
93010     } catch (std::exception& e) {
93011       {
93012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93013       };
93014     } catch (Dali::DaliException e) {
93015       {
93016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93017       };
93018     } catch (...) {
93019       {
93020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93021       };
93022     }
93023   }
93024
93025   jresult = (void *)result;
93026   return jresult;
93027 }
93028
93029
93030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
93031   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93032
93033   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93034   {
93035     try {
93036       delete arg1;
93037     } catch (std::out_of_range& e) {
93038       {
93039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93040       };
93041     } catch (std::exception& e) {
93042       {
93043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93044       };
93045     } catch (Dali::DaliException e) {
93046       {
93047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93048       };
93049     } catch (...) {
93050       {
93051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93052       };
93053     }
93054   }
93055
93056 }
93057
93058
93059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
93060   unsigned int jresult ;
93061   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93062   bool result;
93063
93064   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93065   {
93066     try {
93067       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93068     } catch (std::out_of_range& e) {
93069       {
93070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93071       };
93072     } catch (std::exception& e) {
93073       {
93074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93075       };
93076     } catch (Dali::DaliException e) {
93077       {
93078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93079       };
93080     } catch (...) {
93081       {
93082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93083       };
93084     }
93085   }
93086
93087   jresult = result;
93088   return jresult;
93089 }
93090
93091
93092 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
93093   unsigned long jresult ;
93094   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93095   std::size_t result;
93096
93097   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93098   {
93099     try {
93100       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93101     } catch (std::out_of_range& e) {
93102       {
93103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93104       };
93105     } catch (std::exception& e) {
93106       {
93107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93108       };
93109     } catch (Dali::DaliException e) {
93110       {
93111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93112       };
93113     } catch (...) {
93114       {
93115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93116       };
93117     }
93118   }
93119
93120   jresult = (unsigned long)result;
93121   return jresult;
93122 }
93123
93124
93125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
93126   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93127   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93128
93129   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93130   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93131   {
93132     try {
93133       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
93134     } catch (std::out_of_range& e) {
93135       {
93136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93137       };
93138     } catch (std::exception& e) {
93139       {
93140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93141       };
93142     } catch (Dali::DaliException e) {
93143       {
93144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93145       };
93146     } catch (...) {
93147       {
93148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93149       };
93150     }
93151   }
93152
93153 }
93154
93155
93156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
93157   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93158   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93159
93160   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93161   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93162   {
93163     try {
93164       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
93165     } catch (std::out_of_range& e) {
93166       {
93167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93168       };
93169     } catch (std::exception& e) {
93170       {
93171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93172       };
93173     } catch (Dali::DaliException e) {
93174       {
93175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93176       };
93177     } catch (...) {
93178       {
93179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93180       };
93181     }
93182   }
93183
93184 }
93185
93186
93187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
93188   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93189   Dali::Toolkit::VideoView *arg2 = 0 ;
93190
93191   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93192   arg2 = (Dali::Toolkit::VideoView *)jarg2;
93193   if (!arg2) {
93194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
93195     return ;
93196   }
93197   {
93198     try {
93199       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
93200     } catch (std::out_of_range& e) {
93201       {
93202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93203       };
93204     } catch (std::exception& e) {
93205       {
93206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93207       };
93208     } catch (Dali::DaliException e) {
93209       {
93210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93211       };
93212     } catch (...) {
93213       {
93214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93215       };
93216     }
93217   }
93218
93219 }
93220
93221
93222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
93223   void * jresult ;
93224   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
93225
93226   {
93227     try {
93228       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
93229     } catch (std::out_of_range& e) {
93230       {
93231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93232       };
93233     } catch (std::exception& e) {
93234       {
93235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93236       };
93237     } catch (Dali::DaliException e) {
93238       {
93239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93240       };
93241     } catch (...) {
93242       {
93243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93244       };
93245     }
93246   }
93247
93248   jresult = (void *)result;
93249   return jresult;
93250 }
93251
93252
93253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
93254   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93255
93256   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93257   {
93258     try {
93259       delete arg1;
93260     } catch (std::out_of_range& e) {
93261       {
93262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93263       };
93264     } catch (std::exception& e) {
93265       {
93266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93267       };
93268     } catch (Dali::DaliException e) {
93269       {
93270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93271       };
93272     } catch (...) {
93273       {
93274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93275       };
93276     }
93277   }
93278
93279 }
93280
93281
93282 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
93283   unsigned int jresult ;
93284   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93285   bool result;
93286
93287   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93288   {
93289     try {
93290       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93291     } catch (std::out_of_range& e) {
93292       {
93293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93294       };
93295     } catch (std::exception& e) {
93296       {
93297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93298       };
93299     } catch (Dali::DaliException e) {
93300       {
93301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93302       };
93303     } catch (...) {
93304       {
93305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93306       };
93307     }
93308   }
93309
93310   jresult = result;
93311   return jresult;
93312 }
93313
93314
93315 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
93316   unsigned long jresult ;
93317   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93318   std::size_t result;
93319
93320   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93321   {
93322     try {
93323       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93324     } catch (std::out_of_range& e) {
93325       {
93326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93327       };
93328     } catch (std::exception& e) {
93329       {
93330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93331       };
93332     } catch (Dali::DaliException e) {
93333       {
93334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93335       };
93336     } catch (...) {
93337       {
93338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93339       };
93340     }
93341   }
93342
93343   jresult = (unsigned long)result;
93344   return jresult;
93345 }
93346
93347
93348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
93349   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93350   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93351
93352   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93353   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93354   {
93355     try {
93356       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
93357     } catch (std::out_of_range& e) {
93358       {
93359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93360       };
93361     } catch (std::exception& e) {
93362       {
93363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93364       };
93365     } catch (Dali::DaliException e) {
93366       {
93367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93368       };
93369     } catch (...) {
93370       {
93371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93372       };
93373     }
93374   }
93375
93376 }
93377
93378
93379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
93380   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93381   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93382
93383   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93384   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93385   {
93386     try {
93387       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
93388     } catch (std::out_of_range& e) {
93389       {
93390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93391       };
93392     } catch (std::exception& e) {
93393       {
93394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93395       };
93396     } catch (Dali::DaliException e) {
93397       {
93398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93399       };
93400     } catch (...) {
93401       {
93402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93403       };
93404     }
93405   }
93406
93407 }
93408
93409
93410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
93411   unsigned int jresult ;
93412   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93413   Dali::Toolkit::Slider arg2 ;
93414   float arg3 ;
93415   Dali::Toolkit::Slider *argp2 ;
93416   bool result;
93417
93418   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93419   argp2 = (Dali::Toolkit::Slider *)jarg2;
93420   if (!argp2) {
93421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
93422     return 0;
93423   }
93424   arg2 = *argp2;
93425   arg3 = (float)jarg3;
93426   {
93427     try {
93428       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
93429     } catch (std::out_of_range& e) {
93430       {
93431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93432       };
93433     } catch (std::exception& e) {
93434       {
93435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93436       };
93437     } catch (Dali::DaliException e) {
93438       {
93439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93440       };
93441     } catch (...) {
93442       {
93443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93444       };
93445     }
93446   }
93447
93448   jresult = result;
93449   return jresult;
93450 }
93451
93452
93453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
93454   void * jresult ;
93455   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
93456
93457   {
93458     try {
93459       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
93460     } catch (std::out_of_range& e) {
93461       {
93462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93463       };
93464     } catch (std::exception& e) {
93465       {
93466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93467       };
93468     } catch (Dali::DaliException e) {
93469       {
93470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93471       };
93472     } catch (...) {
93473       {
93474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93475       };
93476     }
93477   }
93478
93479   jresult = (void *)result;
93480   return jresult;
93481 }
93482
93483
93484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
93485   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93486
93487   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93488   {
93489     try {
93490       delete arg1;
93491     } catch (std::out_of_range& e) {
93492       {
93493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93494       };
93495     } catch (std::exception& e) {
93496       {
93497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93498       };
93499     } catch (Dali::DaliException e) {
93500       {
93501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93502       };
93503     } catch (...) {
93504       {
93505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93506       };
93507     }
93508   }
93509
93510 }
93511
93512
93513 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
93514   unsigned int jresult ;
93515   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93516   bool result;
93517
93518   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93519   {
93520     try {
93521       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
93522     } catch (std::out_of_range& e) {
93523       {
93524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93525       };
93526     } catch (std::exception& e) {
93527       {
93528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93529       };
93530     } catch (Dali::DaliException e) {
93531       {
93532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93533       };
93534     } catch (...) {
93535       {
93536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93537       };
93538     }
93539   }
93540
93541   jresult = result;
93542   return jresult;
93543 }
93544
93545
93546 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
93547   unsigned long jresult ;
93548   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93549   std::size_t result;
93550
93551   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93552   {
93553     try {
93554       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
93555     } catch (std::out_of_range& e) {
93556       {
93557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93558       };
93559     } catch (std::exception& e) {
93560       {
93561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93562       };
93563     } catch (Dali::DaliException e) {
93564       {
93565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93566       };
93567     } catch (...) {
93568       {
93569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93570       };
93571     }
93572   }
93573
93574   jresult = (unsigned long)result;
93575   return jresult;
93576 }
93577
93578
93579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
93580   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93581   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
93582
93583   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93584   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
93585   {
93586     try {
93587       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
93588     } catch (std::out_of_range& e) {
93589       {
93590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93591       };
93592     } catch (std::exception& e) {
93593       {
93594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93595       };
93596     } catch (Dali::DaliException e) {
93597       {
93598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93599       };
93600     } catch (...) {
93601       {
93602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93603       };
93604     }
93605   }
93606
93607 }
93608
93609
93610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
93611   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93612   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
93613
93614   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93615   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
93616   {
93617     try {
93618       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
93619     } catch (std::out_of_range& e) {
93620       {
93621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93622       };
93623     } catch (std::exception& e) {
93624       {
93625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93626       };
93627     } catch (Dali::DaliException e) {
93628       {
93629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93630       };
93631     } catch (...) {
93632       {
93633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93634       };
93635     }
93636   }
93637
93638 }
93639
93640
93641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
93642   unsigned int jresult ;
93643   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93644   Dali::Toolkit::Slider arg2 ;
93645   int arg3 ;
93646   Dali::Toolkit::Slider *argp2 ;
93647   bool result;
93648
93649   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93650   argp2 = (Dali::Toolkit::Slider *)jarg2;
93651   if (!argp2) {
93652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
93653     return 0;
93654   }
93655   arg2 = *argp2;
93656   arg3 = (int)jarg3;
93657   {
93658     try {
93659       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
93660     } catch (std::out_of_range& e) {
93661       {
93662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93663       };
93664     } catch (std::exception& e) {
93665       {
93666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93667       };
93668     } catch (Dali::DaliException e) {
93669       {
93670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93671       };
93672     } catch (...) {
93673       {
93674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93675       };
93676     }
93677   }
93678
93679   jresult = result;
93680   return jresult;
93681 }
93682
93683
93684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
93685   void * jresult ;
93686   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
93687
93688   {
93689     try {
93690       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
93691     } catch (std::out_of_range& e) {
93692       {
93693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93694       };
93695     } catch (std::exception& e) {
93696       {
93697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93698       };
93699     } catch (Dali::DaliException e) {
93700       {
93701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93702       };
93703     } catch (...) {
93704       {
93705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93706       };
93707     }
93708   }
93709
93710   jresult = (void *)result;
93711   return jresult;
93712 }
93713
93714
93715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
93716   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93717
93718   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93719   {
93720     try {
93721       delete arg1;
93722     } catch (std::out_of_range& e) {
93723       {
93724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93725       };
93726     } catch (std::exception& e) {
93727       {
93728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93729       };
93730     } catch (Dali::DaliException e) {
93731       {
93732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93733       };
93734     } catch (...) {
93735       {
93736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93737       };
93738     }
93739   }
93740
93741 }
93742
93743
93744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
93745   void * jresult ;
93746   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93747
93748   {
93749     try {
93750       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
93751     } catch (std::out_of_range& e) {
93752       {
93753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93754       };
93755     } catch (std::exception& e) {
93756       {
93757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93758       };
93759     } catch (Dali::DaliException e) {
93760       {
93761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93762       };
93763     } catch (...) {
93764       {
93765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93766       };
93767     }
93768   }
93769
93770   jresult = (void *)result;
93771   return jresult;
93772 }
93773
93774
93775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
93776   void * jresult ;
93777   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
93778   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93779
93780   arg1 = (Dali::Toolkit::Ruler *)jarg1;
93781   {
93782     try {
93783       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
93784     } catch (std::out_of_range& e) {
93785       {
93786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93787       };
93788     } catch (std::exception& e) {
93789       {
93790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93791       };
93792     } catch (Dali::DaliException e) {
93793       {
93794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93795       };
93796     } catch (...) {
93797       {
93798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93799       };
93800     }
93801   }
93802
93803   jresult = (void *)result;
93804   return jresult;
93805 }
93806
93807
93808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
93809   void * jresult ;
93810   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
93811   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93812
93813   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93814   if (!arg1) {
93815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
93816     return 0;
93817   }
93818   {
93819     try {
93820       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
93821     } catch (std::out_of_range& e) {
93822       {
93823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93824       };
93825     } catch (std::exception& e) {
93826       {
93827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93828       };
93829     } catch (Dali::DaliException e) {
93830       {
93831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93832       };
93833     } catch (...) {
93834       {
93835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93836       };
93837     }
93838   }
93839
93840   jresult = (void *)result;
93841   return jresult;
93842 }
93843
93844
93845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
93846   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93847
93848   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93849   {
93850     try {
93851       delete arg1;
93852     } catch (std::out_of_range& e) {
93853       {
93854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93855       };
93856     } catch (std::exception& e) {
93857       {
93858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93859       };
93860     } catch (Dali::DaliException e) {
93861       {
93862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93863       };
93864     } catch (...) {
93865       {
93866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93867       };
93868     }
93869   }
93870
93871 }
93872
93873
93874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
93875   void * jresult ;
93876   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93877   Dali::Toolkit::Ruler *result = 0 ;
93878
93879   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93880   {
93881     try {
93882       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
93883     } catch (std::out_of_range& e) {
93884       {
93885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93886       };
93887     } catch (std::exception& e) {
93888       {
93889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93890       };
93891     } catch (Dali::DaliException e) {
93892       {
93893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93894       };
93895     } catch (...) {
93896       {
93897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93898       };
93899     }
93900   }
93901
93902   jresult = (void *)result;
93903   return jresult;
93904 }
93905
93906
93907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
93908   void * jresult ;
93909   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93910   Dali::Toolkit::Ruler *result = 0 ;
93911
93912   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93913   {
93914     try {
93915       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
93916     } catch (std::out_of_range& e) {
93917       {
93918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93919       };
93920     } catch (std::exception& e) {
93921       {
93922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93923       };
93924     } catch (Dali::DaliException e) {
93925       {
93926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93927       };
93928     } catch (...) {
93929       {
93930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93931       };
93932     }
93933   }
93934
93935   jresult = (void *)result;
93936   return jresult;
93937 }
93938
93939
93940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
93941   void * jresult ;
93942   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93943   Dali::Toolkit::Ruler *result = 0 ;
93944
93945   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93946   {
93947     try {
93948       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
93949     } catch (std::out_of_range& e) {
93950       {
93951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93952       };
93953     } catch (std::exception& e) {
93954       {
93955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93956       };
93957     } catch (Dali::DaliException e) {
93958       {
93959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93960       };
93961     } catch (...) {
93962       {
93963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93964       };
93965     }
93966   }
93967
93968   jresult = (void *)result;
93969   return jresult;
93970 }
93971
93972
93973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
93974   void * jresult ;
93975   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93976   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
93977   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93978
93979   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93980   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
93981   if (!arg2) {
93982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
93983     return 0;
93984   }
93985   {
93986     try {
93987       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
93988     } catch (std::out_of_range& e) {
93989       {
93990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93991       };
93992     } catch (std::exception& e) {
93993       {
93994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93995       };
93996     } catch (Dali::DaliException e) {
93997       {
93998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93999       };
94000     } catch (...) {
94001       {
94002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94003       };
94004     }
94005   }
94006
94007   jresult = (void *)result;
94008   return jresult;
94009 }
94010
94011
94012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
94013   void * jresult ;
94014   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94015   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
94016   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94017
94018   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94019   arg2 = (Dali::Toolkit::Ruler *)jarg2;
94020   {
94021     try {
94022       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
94023     } catch (std::out_of_range& e) {
94024       {
94025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94026       };
94027     } catch (std::exception& e) {
94028       {
94029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94030       };
94031     } catch (Dali::DaliException e) {
94032       {
94033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94034       };
94035     } catch (...) {
94036       {
94037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94038       };
94039     }
94040   }
94041
94042   jresult = (void *)result;
94043   return jresult;
94044 }
94045
94046
94047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
94048   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94049
94050   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94051   {
94052     try {
94053       (arg1)->Reset();
94054     } catch (std::out_of_range& e) {
94055       {
94056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94057       };
94058     } catch (std::exception& e) {
94059       {
94060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94061       };
94062     } catch (Dali::DaliException e) {
94063       {
94064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94065       };
94066     } catch (...) {
94067       {
94068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94069       };
94070     }
94071   }
94072
94073 }
94074
94075
94076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
94077   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94078   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
94079
94080   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94081   arg2 = (Dali::Toolkit::Ruler *)jarg2;
94082   {
94083     try {
94084       (arg1)->Reset(arg2);
94085     } catch (std::out_of_range& e) {
94086       {
94087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94088       };
94089     } catch (std::exception& e) {
94090       {
94091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94092       };
94093     } catch (Dali::DaliException e) {
94094       {
94095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94096       };
94097     } catch (...) {
94098       {
94099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94100       };
94101     }
94102   }
94103
94104 }
94105
94106
94107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
94108   void * jresult ;
94109   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94110   Dali::Toolkit::Ruler *result = 0 ;
94111
94112   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94113   {
94114     try {
94115       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
94116     } catch (std::out_of_range& e) {
94117       {
94118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94119       };
94120     } catch (std::exception& e) {
94121       {
94122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94123       };
94124     } catch (Dali::DaliException e) {
94125       {
94126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94127       };
94128     } catch (...) {
94129       {
94130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94131       };
94132     }
94133   }
94134
94135   jresult = (void *)result;
94136   return jresult;
94137 }
94138
94139
94140 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
94141   float jresult ;
94142   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94143   float arg2 ;
94144   float arg3 ;
94145   float result;
94146
94147   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94148   arg2 = (float)jarg2;
94149   arg3 = (float)jarg3;
94150   {
94151     try {
94152       result = (float)(*arg1)->Snap(arg2,arg3);
94153     } catch (std::out_of_range& e) {
94154       {
94155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94156       };
94157     } catch (std::exception& e) {
94158       {
94159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94160       };
94161     } catch (Dali::DaliException e) {
94162       {
94163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94164       };
94165     } catch (...) {
94166       {
94167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94168       };
94169     }
94170   }
94171
94172   jresult = result;
94173   return jresult;
94174 }
94175
94176
94177 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
94178   float jresult ;
94179   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94180   float arg2 ;
94181   float result;
94182
94183   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94184   arg2 = (float)jarg2;
94185   {
94186     try {
94187       result = (float)(*arg1)->Snap(arg2);
94188     } catch (std::out_of_range& e) {
94189       {
94190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94191       };
94192     } catch (std::exception& e) {
94193       {
94194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94195       };
94196     } catch (Dali::DaliException e) {
94197       {
94198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94199       };
94200     } catch (...) {
94201       {
94202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94203       };
94204     }
94205   }
94206
94207   jresult = result;
94208   return jresult;
94209 }
94210
94211
94212 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
94213   float jresult ;
94214   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94215   unsigned int arg2 ;
94216   unsigned int *arg3 = 0 ;
94217   bool arg4 ;
94218   float result;
94219
94220   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94221   arg2 = (unsigned int)jarg2;
94222   arg3 = (unsigned int *)jarg3;
94223   arg4 = jarg4 ? true : false;
94224   {
94225     try {
94226       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
94227     } catch (std::out_of_range& e) {
94228       {
94229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94230       };
94231     } catch (std::exception& e) {
94232       {
94233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94234       };
94235     } catch (Dali::DaliException e) {
94236       {
94237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94238       };
94239     } catch (...) {
94240       {
94241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94242       };
94243     }
94244   }
94245
94246   jresult = result;
94247   return jresult;
94248 }
94249
94250
94251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
94252   unsigned int jresult ;
94253   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94254   float arg2 ;
94255   bool arg3 ;
94256   unsigned int result;
94257
94258   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94259   arg2 = (float)jarg2;
94260   arg3 = jarg3 ? true : false;
94261   {
94262     try {
94263       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
94264     } catch (std::out_of_range& e) {
94265       {
94266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94267       };
94268     } catch (std::exception& e) {
94269       {
94270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94271       };
94272     } catch (Dali::DaliException e) {
94273       {
94274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94275       };
94276     } catch (...) {
94277       {
94278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94279       };
94280     }
94281   }
94282
94283   jresult = result;
94284   return jresult;
94285 }
94286
94287
94288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
94289   unsigned int jresult ;
94290   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94291   unsigned int result;
94292
94293   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94294   {
94295     try {
94296       result = (unsigned int)(*arg1)->GetTotalPages();
94297     } catch (std::out_of_range& e) {
94298       {
94299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94300       };
94301     } catch (std::exception& e) {
94302       {
94303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94304       };
94305     } catch (Dali::DaliException e) {
94306       {
94307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94308       };
94309     } catch (...) {
94310       {
94311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94312       };
94313     }
94314   }
94315
94316   jresult = result;
94317   return jresult;
94318 }
94319
94320
94321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
94322   int jresult ;
94323   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94324   Dali::Toolkit::Ruler::RulerType result;
94325
94326   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94327   {
94328     try {
94329       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
94330     } catch (std::out_of_range& e) {
94331       {
94332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94333       };
94334     } catch (std::exception& e) {
94335       {
94336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94337       };
94338     } catch (Dali::DaliException e) {
94339       {
94340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94341       };
94342     } catch (...) {
94343       {
94344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94345       };
94346     }
94347   }
94348
94349   jresult = (int)result;
94350   return jresult;
94351 }
94352
94353
94354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
94355   unsigned int jresult ;
94356   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94357   bool result;
94358
94359   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94360   {
94361     try {
94362       result = (bool)(*arg1)->IsEnabled();
94363     } catch (std::out_of_range& e) {
94364       {
94365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94366       };
94367     } catch (std::exception& e) {
94368       {
94369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94370       };
94371     } catch (Dali::DaliException e) {
94372       {
94373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94374       };
94375     } catch (...) {
94376       {
94377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94378       };
94379     }
94380   }
94381
94382   jresult = result;
94383   return jresult;
94384 }
94385
94386
94387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
94388   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94389
94390   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94391   {
94392     try {
94393       (*arg1)->Enable();
94394     } catch (std::out_of_range& e) {
94395       {
94396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94397       };
94398     } catch (std::exception& e) {
94399       {
94400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94401       };
94402     } catch (Dali::DaliException e) {
94403       {
94404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94405       };
94406     } catch (...) {
94407       {
94408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94409       };
94410     }
94411   }
94412
94413 }
94414
94415
94416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
94417   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94418
94419   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94420   {
94421     try {
94422       (*arg1)->Disable();
94423     } catch (std::out_of_range& e) {
94424       {
94425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94426       };
94427     } catch (std::exception& e) {
94428       {
94429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94430       };
94431     } catch (Dali::DaliException e) {
94432       {
94433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94434       };
94435     } catch (...) {
94436       {
94437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94438       };
94439     }
94440   }
94441
94442 }
94443
94444
94445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
94446   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94447   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
94448   Dali::Toolkit::RulerDomain *argp2 ;
94449
94450   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94451   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
94452   if (!argp2) {
94453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
94454     return ;
94455   }
94456   arg2 = *argp2;
94457   {
94458     try {
94459       (*arg1)->SetDomain(arg2);
94460     } catch (std::out_of_range& e) {
94461       {
94462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94463       };
94464     } catch (std::exception& e) {
94465       {
94466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94467       };
94468     } catch (Dali::DaliException e) {
94469       {
94470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94471       };
94472     } catch (...) {
94473       {
94474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94475       };
94476     }
94477   }
94478
94479 }
94480
94481
94482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
94483   void * jresult ;
94484   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94485   Dali::Toolkit::RulerDomain *result = 0 ;
94486
94487   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94488   {
94489     try {
94490       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
94491     } catch (std::out_of_range& e) {
94492       {
94493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94494       };
94495     } catch (std::exception& e) {
94496       {
94497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94498       };
94499     } catch (Dali::DaliException e) {
94500       {
94501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94502       };
94503     } catch (...) {
94504       {
94505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94506       };
94507     }
94508   }
94509
94510   jresult = (void *)result;
94511   return jresult;
94512 }
94513
94514
94515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
94516   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94517
94518   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94519   {
94520     try {
94521       (*arg1)->DisableDomain();
94522     } catch (std::out_of_range& e) {
94523       {
94524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94525       };
94526     } catch (std::exception& e) {
94527       {
94528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94529       };
94530     } catch (Dali::DaliException e) {
94531       {
94532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94533       };
94534     } catch (...) {
94535       {
94536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94537       };
94538     }
94539   }
94540
94541 }
94542
94543
94544 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
94545   float jresult ;
94546   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94547   float arg2 ;
94548   float arg3 ;
94549   float arg4 ;
94550   float result;
94551
94552   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94553   arg2 = (float)jarg2;
94554   arg3 = (float)jarg3;
94555   arg4 = (float)jarg4;
94556   {
94557     try {
94558       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
94559     } catch (std::out_of_range& e) {
94560       {
94561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94562       };
94563     } catch (std::exception& e) {
94564       {
94565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94566       };
94567     } catch (Dali::DaliException e) {
94568       {
94569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94570       };
94571     } catch (...) {
94572       {
94573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94574       };
94575     }
94576   }
94577
94578   jresult = result;
94579   return jresult;
94580 }
94581
94582
94583 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
94584   float jresult ;
94585   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94586   float arg2 ;
94587   float arg3 ;
94588   float result;
94589
94590   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94591   arg2 = (float)jarg2;
94592   arg3 = (float)jarg3;
94593   {
94594     try {
94595       result = (float)(*arg1)->Clamp(arg2,arg3);
94596     } catch (std::out_of_range& e) {
94597       {
94598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94599       };
94600     } catch (std::exception& e) {
94601       {
94602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94603       };
94604     } catch (Dali::DaliException e) {
94605       {
94606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94607       };
94608     } catch (...) {
94609       {
94610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94611       };
94612     }
94613   }
94614
94615   jresult = result;
94616   return jresult;
94617 }
94618
94619
94620 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
94621   float jresult ;
94622   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94623   float arg2 ;
94624   float result;
94625
94626   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94627   arg2 = (float)jarg2;
94628   {
94629     try {
94630       result = (float)(*arg1)->Clamp(arg2);
94631     } catch (std::out_of_range& e) {
94632       {
94633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94634       };
94635     } catch (std::exception& e) {
94636       {
94637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94638       };
94639     } catch (Dali::DaliException e) {
94640       {
94641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94642       };
94643     } catch (...) {
94644       {
94645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94646       };
94647     }
94648   }
94649
94650   jresult = result;
94651   return jresult;
94652 }
94653
94654
94655 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
94656   float jresult ;
94657   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94658   float arg2 ;
94659   float arg3 ;
94660   float arg4 ;
94661   Dali::Toolkit::ClampState *arg5 = 0 ;
94662   float result;
94663
94664   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94665   arg2 = (float)jarg2;
94666   arg3 = (float)jarg3;
94667   arg4 = (float)jarg4;
94668   arg5 = (Dali::Toolkit::ClampState *)jarg5;
94669   if (!arg5) {
94670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
94671     return 0;
94672   }
94673   {
94674     try {
94675       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
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_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
94701   float jresult ;
94702   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94703   float arg2 ;
94704   float arg3 ;
94705   float arg4 ;
94706   float arg5 ;
94707   float result;
94708
94709   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94710   arg2 = (float)jarg2;
94711   arg3 = (float)jarg3;
94712   arg4 = (float)jarg4;
94713   arg5 = (float)jarg5;
94714   {
94715     try {
94716       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
94717     } catch (std::out_of_range& e) {
94718       {
94719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94720       };
94721     } catch (std::exception& e) {
94722       {
94723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94724       };
94725     } catch (Dali::DaliException e) {
94726       {
94727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94728       };
94729     } catch (...) {
94730       {
94731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94732       };
94733     }
94734   }
94735
94736   jresult = result;
94737   return jresult;
94738 }
94739
94740
94741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
94742   float jresult ;
94743   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94744   float arg2 ;
94745   float arg3 ;
94746   float arg4 ;
94747   float result;
94748
94749   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94750   arg2 = (float)jarg2;
94751   arg3 = (float)jarg3;
94752   arg4 = (float)jarg4;
94753   {
94754     try {
94755       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
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_2(void * jarg1, float jarg2, float jarg3) {
94781   float jresult ;
94782   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94783   float arg2 ;
94784   float arg3 ;
94785   float result;
94786
94787   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94788   arg2 = (float)jarg2;
94789   arg3 = (float)jarg3;
94790   {
94791     try {
94792       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
94793     } catch (std::out_of_range& e) {
94794       {
94795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94796       };
94797     } catch (std::exception& e) {
94798       {
94799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94800       };
94801     } catch (Dali::DaliException e) {
94802       {
94803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94804       };
94805     } catch (...) {
94806       {
94807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94808       };
94809     }
94810   }
94811
94812   jresult = result;
94813   return jresult;
94814 }
94815
94816
94817 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
94818   float jresult ;
94819   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94820   float arg2 ;
94821   float result;
94822
94823   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94824   arg2 = (float)jarg2;
94825   {
94826     try {
94827       result = (float)(*arg1)->SnapAndClamp(arg2);
94828     } catch (std::out_of_range& e) {
94829       {
94830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94831       };
94832     } catch (std::exception& e) {
94833       {
94834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94835       };
94836     } catch (Dali::DaliException e) {
94837       {
94838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94839       };
94840     } catch (...) {
94841       {
94842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94843       };
94844     }
94845   }
94846
94847   jresult = result;
94848   return jresult;
94849 }
94850
94851
94852 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
94853   float jresult ;
94854   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94855   float arg2 ;
94856   float arg3 ;
94857   float arg4 ;
94858   float arg5 ;
94859   Dali::Toolkit::ClampState *arg6 = 0 ;
94860   float result;
94861
94862   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94863   arg2 = (float)jarg2;
94864   arg3 = (float)jarg3;
94865   arg4 = (float)jarg4;
94866   arg5 = (float)jarg5;
94867   arg6 = (Dali::Toolkit::ClampState *)jarg6;
94868   if (!arg6) {
94869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
94870     return 0;
94871   }
94872   {
94873     try {
94874       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
94875     } catch (std::out_of_range& e) {
94876       {
94877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94878       };
94879     } catch (std::exception& e) {
94880       {
94881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94882       };
94883     } catch (Dali::DaliException e) {
94884       {
94885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94886       };
94887     } catch (...) {
94888       {
94889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94890       };
94891     }
94892   }
94893
94894   jresult = result;
94895   return jresult;
94896 }
94897
94898
94899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
94900   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94901
94902   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94903   {
94904     try {
94905       (*arg1)->Reference();
94906     } catch (std::out_of_range& e) {
94907       {
94908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94909       };
94910     } catch (std::exception& e) {
94911       {
94912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94913       };
94914     } catch (Dali::DaliException e) {
94915       {
94916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94917       };
94918     } catch (...) {
94919       {
94920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94921       };
94922     }
94923   }
94924
94925 }
94926
94927
94928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
94929   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94930
94931   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94932   {
94933     try {
94934       (*arg1)->Unreference();
94935     } catch (std::out_of_range& e) {
94936       {
94937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94938       };
94939     } catch (std::exception& e) {
94940       {
94941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94942       };
94943     } catch (Dali::DaliException e) {
94944       {
94945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94946       };
94947     } catch (...) {
94948       {
94949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94950       };
94951     }
94952   }
94953
94954 }
94955
94956
94957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
94958   int jresult ;
94959   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94960   int result;
94961
94962   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94963   {
94964     try {
94965       result = (int)(*arg1)->ReferenceCount();
94966     } catch (std::out_of_range& e) {
94967       {
94968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94969       };
94970     } catch (std::exception& e) {
94971       {
94972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94973       };
94974     } catch (Dali::DaliException e) {
94975       {
94976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94977       };
94978     } catch (...) {
94979       {
94980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94981       };
94982     }
94983   }
94984
94985   jresult = result;
94986   return jresult;
94987 }
94988
94989
94990 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
94991   unsigned int jresult ;
94992   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94993   bool result;
94994
94995   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94996   {
94997     try {
94998       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
94999     } catch (std::out_of_range& e) {
95000       {
95001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95002       };
95003     } catch (std::exception& e) {
95004       {
95005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95006       };
95007     } catch (Dali::DaliException e) {
95008       {
95009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95010       };
95011     } catch (...) {
95012       {
95013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95014       };
95015     }
95016   }
95017
95018   jresult = result;
95019   return jresult;
95020 }
95021
95022
95023 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
95024   unsigned long jresult ;
95025   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95026   std::size_t result;
95027
95028   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95029   {
95030     try {
95031       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95032     } catch (std::out_of_range& e) {
95033       {
95034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95035       };
95036     } catch (std::exception& e) {
95037       {
95038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95039       };
95040     } catch (Dali::DaliException e) {
95041       {
95042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95043       };
95044     } catch (...) {
95045       {
95046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95047       };
95048     }
95049   }
95050
95051   jresult = (unsigned long)result;
95052   return jresult;
95053 }
95054
95055
95056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
95057   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95058   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95059
95060   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95061   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95062   {
95063     try {
95064       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
95065     } catch (std::out_of_range& e) {
95066       {
95067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95068       };
95069     } catch (std::exception& e) {
95070       {
95071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95072       };
95073     } catch (Dali::DaliException e) {
95074       {
95075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95076       };
95077     } catch (...) {
95078       {
95079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95080       };
95081     }
95082   }
95083
95084 }
95085
95086
95087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
95088   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95089   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95090
95091   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95092   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95093   {
95094     try {
95095       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
95096     } catch (std::out_of_range& e) {
95097       {
95098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95099       };
95100     } catch (std::exception& e) {
95101       {
95102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95103       };
95104     } catch (Dali::DaliException e) {
95105       {
95106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95107       };
95108     } catch (...) {
95109       {
95110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95111       };
95112     }
95113   }
95114
95115 }
95116
95117
95118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
95119   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95120   Dali::Toolkit::Control arg2 ;
95121   Dali::Toolkit::Control *argp2 ;
95122
95123   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95124   argp2 = (Dali::Toolkit::Control *)jarg2;
95125   if (!argp2) {
95126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
95127     return ;
95128   }
95129   arg2 = *argp2;
95130   {
95131     try {
95132       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
95133     } catch (std::out_of_range& e) {
95134       {
95135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95136       };
95137     } catch (std::exception& e) {
95138       {
95139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95140       };
95141     } catch (Dali::DaliException e) {
95142       {
95143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95144       };
95145     } catch (...) {
95146       {
95147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95148       };
95149     }
95150   }
95151
95152 }
95153
95154
95155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
95156   void * jresult ;
95157   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
95158
95159   {
95160     try {
95161       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
95162     } catch (std::out_of_range& e) {
95163       {
95164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95165       };
95166     } catch (std::exception& e) {
95167       {
95168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95169       };
95170     } catch (Dali::DaliException e) {
95171       {
95172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95173       };
95174     } catch (...) {
95175       {
95176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95177       };
95178     }
95179   }
95180
95181   jresult = (void *)result;
95182   return jresult;
95183 }
95184
95185
95186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
95187   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95188
95189   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95190   {
95191     try {
95192       delete arg1;
95193     } catch (std::out_of_range& e) {
95194       {
95195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95196       };
95197     } catch (std::exception& e) {
95198       {
95199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95200       };
95201     } catch (Dali::DaliException e) {
95202       {
95203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95204       };
95205     } catch (...) {
95206       {
95207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95208       };
95209     }
95210   }
95211
95212 }
95213
95214 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
95215   Dali::RefObject *result = NULL;
95216
95217   if (arg1)
95218   {
95219     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
95220   }
95221   return result;
95222 }
95223
95224 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
95225     return (Dali::RefObject *)jarg1;
95226 }
95227
95228 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
95229     return (Dali::SignalObserver *)jarg1;
95230 }
95231
95232 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
95233     return (Dali::ConnectionTrackerInterface *)jarg1;
95234 }
95235
95236 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
95237     return (Dali::BaseHandle *)jarg1;
95238 }
95239
95240 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
95241     return (Dali::BaseHandle *)jarg1;
95242 }
95243
95244 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
95245     return (Dali::BaseHandle *)jarg1;
95246 }
95247
95248 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
95249     return (Dali::BaseHandle *)jarg1;
95250 }
95251
95252 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
95253     return (Dali::BaseHandle *)jarg1;
95254 }
95255
95256 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
95257     return (Dali::BaseHandle *)jarg1;
95258 }
95259
95260 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
95261     return (Dali::BaseHandle *)jarg1;
95262 }
95263
95264 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
95265     return (Dali::BaseHandle *)jarg1;
95266 }
95267
95268 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
95269     return (Dali::BaseHandle *)jarg1;
95270 }
95271
95272 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
95273     return (Dali::BaseHandle *)jarg1;
95274 }
95275
95276 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
95277     return (Dali::BaseHandle *)jarg1;
95278 }
95279
95280 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
95281     return (Dali::BaseHandle *)jarg1;
95282 }
95283
95284 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
95285     return (Dali::Handle *)jarg1;
95286 }
95287
95288 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
95289     return (Dali::Handle *)jarg1;
95290 }
95291
95292 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
95293     return (Dali::BaseHandle *)jarg1;
95294 }
95295
95296 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
95297     return (Dali::BaseHandle *)jarg1;
95298 }
95299
95300 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
95301     return (Dali::Handle *)jarg1;
95302 }
95303
95304 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
95305     return (Dali::BaseHandle *)jarg1;
95306 }
95307
95308 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
95309     return (Dali::Handle *)jarg1;
95310 }
95311
95312 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
95313     return (Dali::GestureDetector *)jarg1;
95314 }
95315
95316 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
95317     return (Dali::Gesture *)jarg1;
95318 }
95319
95320 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
95321     return (Dali::Handle *)jarg1;
95322 }
95323
95324 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
95325     return (Dali::Actor *)jarg1;
95326 }
95327
95328 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
95329     return (Dali::RefObject *)jarg1;
95330 }
95331
95332 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
95333     return (Dali::Actor *)jarg1;
95334 }
95335
95336 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
95337     return (Dali::GestureDetector *)jarg1;
95338 }
95339
95340 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
95341     return (Dali::Gesture *)jarg1;
95342 }
95343
95344 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
95345     return (Dali::GestureDetector *)jarg1;
95346 }
95347
95348 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
95349     return (Dali::Gesture *)jarg1;
95350 }
95351
95352 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
95353     return (Dali::GestureDetector *)jarg1;
95354 }
95355
95356 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
95357     return (Dali::Gesture *)jarg1;
95358 }
95359
95360 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
95361     return (Dali::BaseHandle *)jarg1;
95362 }
95363
95364 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
95365     return (Dali::Handle *)jarg1;
95366 }
95367
95368 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
95369     return (Dali::Handle *)jarg1;
95370 }
95371
95372 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
95373     return (Dali::Handle *)jarg1;
95374 }
95375
95376 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
95377     return (Dali::RefObject *)jarg1;
95378 }
95379
95380 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
95381     return (Dali::Actor *)jarg1;
95382 }
95383
95384 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
95385     return (Dali::BaseHandle *)jarg1;
95386 }
95387
95388 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
95389     return (Dali::BaseHandle *)jarg1;
95390 }
95391
95392 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
95393     return (Dali::BaseHandle *)jarg1;
95394 }
95395
95396 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
95397     return (Dali::CustomActorImpl *)jarg1;
95398 }
95399
95400 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
95401     return (Dali::CustomActor *)jarg1;
95402 }
95403
95404 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
95405     return (Dali::BaseHandle *)jarg1;
95406 }
95407
95408 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
95409     return (Dali::Toolkit::Control *)jarg1;
95410 }
95411
95412 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
95413     return (Dali::Toolkit::Control *)jarg1;
95414 }
95415
95416 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
95417     return (Dali::Toolkit::Button *)jarg1;
95418 }
95419
95420 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
95421     return (Dali::Toolkit::Button *)jarg1;
95422 }
95423
95424 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
95425     return (Dali::Toolkit::Button *)jarg1;
95426 }
95427
95428 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
95429     return (Dali::Toolkit::Control *)jarg1;
95430 }
95431
95432 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
95433     return (Dali::Toolkit::Control *)jarg1;
95434 }
95435
95436 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
95437     return (Dali::Toolkit::Control *)jarg1;
95438 }
95439
95440 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
95441     return (Dali::Toolkit::Control *)jarg1;
95442 }
95443
95444 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
95445     return (Dali::Toolkit::Control *)jarg1;
95446 }
95447
95448 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
95449     return (Dali::RefObject *)jarg1;
95450 }
95451
95452 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
95453     return (Dali::Toolkit::Scrollable *)jarg1;
95454 }
95455
95456 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
95457     return (Dali::BaseHandle *)jarg1;
95458 }
95459
95460 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
95461     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
95462 }
95463
95464 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
95465     return (Dali::RefObject *)jarg1;
95466 }
95467
95468 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
95469     return (Dali::Toolkit::Ruler *)jarg1;
95470 }
95471
95472 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
95473     return (Dali::Toolkit::Ruler *)jarg1;
95474 }
95475
95476 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
95477     return (Dali::Toolkit::Scrollable *)jarg1;
95478 }
95479
95480 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
95481     return (Dali::Toolkit::Control *)jarg1;
95482 }
95483
95484
95485 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
95486     return (Dali::Toolkit::Control *)jarg1;
95487 }
95488
95489 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
95490     return (Dali::BaseHandle *)jarg1;
95491 }
95492
95493 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
95494     return (Dali::BaseHandle *)jarg1;
95495 }
95496
95497 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
95498     return (Dali::Toolkit::Control *)jarg1;
95499 }
95500
95501 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
95502     return (Dali::Toolkit::Control *)jarg1;
95503 }
95504
95505 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
95506     return (Dali::Toolkit::Control *)jarg1;
95507 }
95508
95509 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
95510     return (Dali::Toolkit::Control *)jarg1;
95511 }
95512
95513 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
95514     return (Dali::Toolkit::Control *)jarg1;
95515 }
95516
95517 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
95518     return (Dali::Toolkit::Control *)jarg1;
95519 }
95520
95521 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
95522     return (Dali::Toolkit::PageTurnView *)jarg1;
95523 }
95524
95525 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
95526     return (Dali::Toolkit::PageTurnView *)jarg1;
95527 }
95528
95529 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
95530     return (Dali::Toolkit::Button *)jarg1;
95531 }
95532
95533 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
95534     return (Dali::BaseHandle *)jarg1;
95535 }
95536
95537 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
95538     return (Dali::BaseHandle *)jarg1;
95539 }
95540
95541 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
95542     return (Dali::BaseHandle *)jarg1;
95543 }
95544
95545 /*
95546  * Widget binding
95547  */
95548 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
95549     return (Dali::BaseHandle *)jarg1;
95550 }
95551
95552 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
95553     return (Dali::BaseObject *)jarg1;
95554 }
95555
95556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
95557   void * jresult ;
95558   Dali::Widget result;
95559
95560   {
95561     try {
95562       result = Dali::Widget::New();
95563     } catch (std::out_of_range& e) {
95564       {
95565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95566       };
95567     } catch (std::exception& e) {
95568       {
95569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95570       };
95571     } catch (...) {
95572       {
95573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95574       };
95575     }
95576   }
95577   jresult = new Dali::Widget((const Dali::Widget &)result);
95578   return jresult;
95579 }
95580
95581
95582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
95583   void * jresult ;
95584   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
95585   Dali::Widget result;
95586
95587   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95588
95589   if (!arg1) {
95590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
95591     return 0;
95592   }
95593   {
95594     try {
95595       jresult = new Dali::Widget(arg1);
95596     } catch (std::out_of_range& e) {
95597       {
95598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95599       };
95600     } catch (std::exception& e) {
95601       {
95602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95603       };
95604     } catch (...) {
95605       {
95606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95607       };
95608     }
95609   }
95610   return jresult;
95611 }
95612
95613
95614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
95615   void * jresult ;
95616   Dali::Widget *result = 0 ;
95617
95618   {
95619     try {
95620       result = (Dali::Widget *)new Dali::Widget();
95621     } catch (std::out_of_range& e) {
95622       {
95623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95624       };
95625     } catch (std::exception& e) {
95626       {
95627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95628       };
95629     } catch (...) {
95630       {
95631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95632       };
95633     }
95634   }
95635   jresult = (void *)result;
95636   return jresult;
95637 }
95638
95639
95640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
95641   void * jresult ;
95642   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
95643   Dali::Widget *arg2 = 0 ;
95644   Dali::Widget *result = 0 ;
95645
95646   arg1 = (Dali::Widget *)jarg1;
95647   arg2 = (Dali::Widget *)jarg2;
95648   if (!arg2) {
95649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
95650     return 0;
95651   }
95652   {
95653     try {
95654       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
95655     } catch (std::out_of_range& e) {
95656       {
95657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95658       };
95659     } catch (std::exception& e) {
95660       {
95661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95662       };
95663     } catch (...) {
95664       {
95665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95666       };
95667     }
95668   }
95669   jresult = (void *)result;
95670   return jresult;
95671 }
95672
95673
95674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
95675   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
95676
95677   arg1 = (Dali::Widget *)jarg1;
95678   {
95679     try {
95680       delete arg1;
95681     } catch (std::out_of_range& e) {
95682       {
95683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95684       };
95685     } catch (std::exception& e) {
95686       {
95687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95688       };
95689     } catch (...) {
95690       {
95691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95692       };
95693     }
95694   }
95695 }
95696
95697
95698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
95699   void * jresult ;
95700   SwigDirector_WidgetImpl* result;
95701   {
95702     try {
95703       result = new SwigDirector_WidgetImpl();
95704     } catch (std::out_of_range& e) {
95705       {
95706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95707       };
95708     } catch (std::exception& e) {
95709       {
95710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95711       };
95712     } catch (...) {
95713       {
95714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95715       };
95716     }
95717   }
95718   jresult = result;
95719   return jresult;
95720 }
95721
95722
95723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
95724   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95725   std::string *arg2 = 0 ;
95726   Dali::Window arg3 ;
95727   Dali::Window *argp3 ;
95728
95729   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95730   if (!jarg2) {
95731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95732     return ;
95733   }
95734   std::string arg2_str(jarg2);
95735   arg2 = &arg2_str;
95736   argp3 = (Dali::Window *)jarg3;
95737   if (!argp3) {
95738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
95739     return ;
95740   }
95741   arg3 = *argp3;
95742   {
95743     try {
95744       (arg1)->OnCreate((std::string const &)*arg2,arg3);
95745     } catch (std::out_of_range& e) {
95746       {
95747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95748       };
95749     } catch (std::exception& e) {
95750       {
95751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95752       };
95753     } catch (...) {
95754       {
95755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95756       };
95757     }
95758   }
95759 }
95760
95761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
95762   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95763   std::string *arg2 = 0 ;
95764   Dali::Window arg3 ;
95765   Dali::Window *argp3 ;
95766
95767   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95768   if (!jarg2) {
95769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95770     return ;
95771   }
95772   std::string arg2_str(jarg2);
95773   arg2 = &arg2_str;
95774   argp3 = (Dali::Window *)jarg3;
95775   if (!argp3) {
95776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
95777     return ;
95778   }
95779   arg3 = *argp3;
95780   {
95781     try {
95782       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
95783     } catch (std::out_of_range& e) {
95784       {
95785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95786       };
95787     } catch (std::exception& e) {
95788       {
95789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95790       };
95791     } catch (...) {
95792       {
95793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95794       };
95795     }
95796   }
95797 }
95798
95799
95800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
95801   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95802   std::string *arg2 = 0 ;
95803   Dali::Widget::Termination arg3 ;
95804
95805   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95806   if (!jarg2) {
95807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95808     return ;
95809   }
95810   std::string arg2_str(jarg2);
95811   arg2 = &arg2_str;
95812   arg3 = (Dali::Widget::Termination)jarg3;
95813   {
95814     try {
95815       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
95816     } catch (std::out_of_range& e) {
95817       {
95818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95819       };
95820     } catch (std::exception& e) {
95821       {
95822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95823       };
95824     } catch (...) {
95825       {
95826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95827       };
95828     }
95829   }
95830 }
95831
95832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
95833   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95834   std::string *arg2 = 0 ;
95835   Dali::Widget::Termination arg3 ;
95836
95837   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95838   if (!jarg2) {
95839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95840     return ;
95841   }
95842   std::string arg2_str(jarg2);
95843   arg2 = &arg2_str;
95844   arg3 = (Dali::Widget::Termination)jarg3;
95845   {
95846     try {
95847       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
95848     } catch (std::out_of_range& e) {
95849       {
95850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95851       };
95852     } catch (std::exception& e) {
95853       {
95854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95855       };
95856     } catch (...) {
95857       {
95858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95859       };
95860     }
95861   }
95862 }
95863
95864
95865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
95866   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95867
95868   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95869   {
95870     try {
95871       (arg1)->OnPause();
95872     } catch (std::out_of_range& e) {
95873       {
95874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95875       };
95876     } catch (std::exception& e) {
95877       {
95878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95879       };
95880     } catch (...) {
95881       {
95882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95883       };
95884     }
95885   }
95886 }
95887
95888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
95889   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95890
95891   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95892   {
95893     try {
95894       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
95895     } catch (std::out_of_range& e) {
95896       {
95897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95898       };
95899     } catch (std::exception& e) {
95900       {
95901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95902       };
95903     } catch (...) {
95904       {
95905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95906       };
95907     }
95908   }
95909 }
95910
95911
95912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
95913   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95914
95915   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95916   {
95917     try {
95918       (arg1)->OnResume();
95919     } catch (std::out_of_range& e) {
95920       {
95921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95922       };
95923     } catch (std::exception& e) {
95924       {
95925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95926       };
95927     } catch (...) {
95928       {
95929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95930       };
95931     }
95932   }
95933 }
95934
95935
95936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
95937   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95938
95939   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95940   {
95941     try {
95942       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
95943     } catch (std::out_of_range& e) {
95944       {
95945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95946       };
95947     } catch (std::exception& e) {
95948       {
95949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95950       };
95951     } catch (...) {
95952       {
95953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95954       };
95955     }
95956   }
95957 }
95958
95959
95960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
95961   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95962   Dali::Window arg2 ;
95963   Dali::Window *argp2 ;
95964
95965   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95966   argp2 = (Dali::Window *)jarg2;
95967   if (!argp2) {
95968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
95969     return ;
95970   }
95971   arg2 = *argp2;
95972   {
95973     try {
95974       (arg1)->OnResize(arg2);
95975     } catch (std::out_of_range& e) {
95976       {
95977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95978       };
95979     } catch (std::exception& e) {
95980       {
95981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95982       };
95983     } catch (...) {
95984       {
95985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95986       };
95987     }
95988   }
95989 }
95990
95991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
95992   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95993   Dali::Window arg2 ;
95994   Dali::Window *argp2 ;
95995
95996   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95997   argp2 = (Dali::Window *)jarg2;
95998   if (!argp2) {
95999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96000     return ;
96001   }
96002   arg2 = *argp2;
96003   {
96004     try {
96005       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
96006     } catch (std::out_of_range& e) {
96007       {
96008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96009       };
96010     } catch (std::exception& e) {
96011       {
96012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96013       };
96014     } catch (...) {
96015       {
96016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96017       };
96018     }
96019   }
96020 }
96021
96022
96023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
96024   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96025   std::string *arg2 = 0 ;
96026   int arg3 ;
96027
96028   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96029   if (!jarg2) {
96030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96031     return ;
96032   }
96033   std::string arg2_str(jarg2);
96034   arg2 = &arg2_str;
96035   arg3 = (int)jarg3;
96036   {
96037     try {
96038       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
96039     } catch (std::out_of_range& e) {
96040       {
96041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96042       };
96043     } catch (std::exception& e) {
96044       {
96045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96046       };
96047     } catch (...) {
96048       {
96049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96050       };
96051     }
96052   }
96053 }
96054
96055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
96056   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96057   std::string *arg2 = 0 ;
96058   int arg3 ;
96059
96060   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96061   if (!jarg2) {
96062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96063     return ;
96064   }
96065   std::string arg2_str(jarg2);
96066   arg2 = &arg2_str;
96067   arg3 = (int)jarg3;
96068   {
96069     try {
96070       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
96071     } catch (std::out_of_range& e) {
96072       {
96073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96074       };
96075     } catch (std::exception& e) {
96076       {
96077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96078       };
96079     } catch (...) {
96080       {
96081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96082       };
96083     }
96084   }
96085 }
96086
96087
96088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
96089   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96090   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96091   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96092
96093   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96094   arg2 = (Dali::SlotObserver *)jarg2;
96095   arg3 = (Dali::CallbackBase *)jarg3;
96096   {
96097     try {
96098       (arg1)->SignalConnected(arg2,arg3);
96099     } catch (std::out_of_range& e) {
96100       {
96101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96102       };
96103     } catch (std::exception& e) {
96104       {
96105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96106       };
96107     } catch (...) {
96108       {
96109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96110       };
96111     }
96112   }
96113 }
96114
96115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96116   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96117   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96118   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96119
96120   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96121   arg2 = (Dali::SlotObserver *)jarg2;
96122   arg3 = (Dali::CallbackBase *)jarg3;
96123   {
96124     try {
96125       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
96126     } catch (std::out_of_range& e) {
96127       {
96128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96129       };
96130     } catch (std::exception& e) {
96131       {
96132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96133       };
96134     } catch (...) {
96135       {
96136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96137       };
96138     }
96139   }
96140 }
96141
96142
96143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
96144   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96145   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96146   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96147
96148   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96149   arg2 = (Dali::SlotObserver *)jarg2;
96150   arg3 = (Dali::CallbackBase *)jarg3;
96151   {
96152     try {
96153       (arg1)->SignalDisconnected(arg2,arg3);
96154     } catch (std::out_of_range& e) {
96155       {
96156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96157       };
96158     } catch (std::exception& e) {
96159       {
96160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96161       };
96162     } catch (...) {
96163       {
96164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96165       };
96166     }
96167   }
96168 }
96169
96170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96171   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96172   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96173   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96174
96175   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96176   arg2 = (Dali::SlotObserver *)jarg2;
96177   arg3 = (Dali::CallbackBase *)jarg3;
96178   {
96179     try {
96180       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
96181     } catch (std::out_of_range& e) {
96182       {
96183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96184       };
96185     } catch (std::exception& e) {
96186       {
96187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96188       };
96189     } catch (...) {
96190       {
96191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96192       };
96193     }
96194   }
96195 }
96196
96197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
96198   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96199   std::string *arg2 = 0 ;
96200
96201   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96202   if (!jarg2) {
96203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96204     return ;
96205   }
96206   std::string arg2_str(jarg2);
96207   arg2 = &arg2_str;
96208   {
96209     try {
96210       (arg1)->SetContentInfo((std::string const &)*arg2);
96211     } catch (std::out_of_range& e) {
96212       {
96213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96214       };
96215     } catch (std::exception& e) {
96216       {
96217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96218       };
96219     } catch (...) {
96220       {
96221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96222       };
96223     }
96224   }
96225 }
96226
96227
96228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
96229   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96230   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
96231
96232   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96233   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
96234   {
96235     try {
96236       (arg1)->SetImpl(arg2);
96237     } catch (std::out_of_range& e) {
96238       {
96239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96240       };
96241     } catch (std::exception& e) {
96242       {
96243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96244       };
96245     } catch (...) {
96246       {
96247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96248       };
96249     }
96250   }
96251 }
96252
96253 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) {
96254
96255   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
96256   if (director) {
96257     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
96258   }
96259 }
96260
96261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
96262   void * jresult ;
96263   Dali::Widget *arg1 = 0 ;
96264   SwigDirector_WidgetImpl *result = 0 ;
96265
96266   arg1 = (Dali::Widget *)jarg1;
96267   if (!arg1) {
96268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
96269     return 0;
96270   }
96271   {
96272     try {
96273       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
96274     } catch (std::out_of_range& e) {
96275       {
96276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96277       };
96278     } catch (std::exception& e) {
96279       {
96280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96281       };
96282     } catch (...) {
96283       {
96284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96285       };
96286     }
96287   }
96288
96289   jresult = (void *)result;
96290   return jresult;
96291 }
96292
96293
96294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
96295   void * jresult ;
96296   int *arg1 = (int *) 0 ;
96297   char ***arg2 ;
96298   std::string *arg3 = 0 ;
96299   Dali::WidgetApplication result;
96300   {
96301     int index = 0;
96302     int length = 0;
96303     char *retPtr;
96304     char *nextPtr;
96305     argWidgetC = jarg1;
96306     argWidgetV = new char*[jarg1 + 1];
96307
96308     retPtr = strtok_r( jarg2, " ", &nextPtr);
96309     if( retPtr )
96310     {
96311       length = strlen(retPtr);
96312     }
96313     argWidgetV[index] = new char[length + 1];
96314     if( retPtr )
96315     {
96316       strncpy(argWidgetV[index], retPtr, length);
96317     }
96318     argWidgetV[index][length] = '\0';
96319     index++;
96320
96321     while (index < jarg1)
96322     {
96323       length = 0;
96324       retPtr = strtok_r(NULL, " ", &nextPtr);
96325       if( retPtr )
96326       {
96327         length = strlen(retPtr);
96328       }
96329       argWidgetV[index] = new char[length + 1];
96330       if( retPtr )
96331       {
96332         strncpy(argWidgetV[index], retPtr, length);
96333       }
96334       argWidgetV[index][length] = '\0';
96335       index++;
96336     }
96337
96338     argWidgetV[jarg1] = NULL;
96339     argWidgetC = jarg1;
96340
96341     arg1 = &argWidgetC;
96342     arg2 = &argWidgetV;
96343   }
96344
96345   if (!jarg3) {
96346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96347     return 0;
96348   }
96349   std::string arg3_str(jarg3);
96350   arg3 = &arg3_str;
96351   {
96352     try {
96353       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
96354     } catch (std::out_of_range& e) {
96355       {
96356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96357       };
96358     } catch (std::exception& e) {
96359       {
96360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96361       };
96362     } catch (...) {
96363       {
96364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96365       };
96366     }
96367   }
96368   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
96369
96370   return jresult;
96371 }
96372
96373
96374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
96375   void * jresult ;
96376   Dali::WidgetApplication *result = 0 ;
96377
96378   {
96379     try {
96380       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
96381     } catch (std::out_of_range& e) {
96382       {
96383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96384       };
96385     } catch (std::exception& e) {
96386       {
96387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96388       };
96389     } catch (...) {
96390       {
96391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96392       };
96393     }
96394   }
96395   jresult = (void *)result;
96396   return jresult;
96397 }
96398
96399
96400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
96401   void * jresult ;
96402   Dali::WidgetApplication *arg1 = 0 ;
96403   Dali::WidgetApplication *result = 0 ;
96404
96405   arg1 = (Dali::WidgetApplication *)jarg1;
96406   if (!arg1) {
96407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96408     return 0;
96409   }
96410   {
96411     try {
96412       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
96413     } catch (std::out_of_range& e) {
96414       {
96415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96416       };
96417     } catch (std::exception& e) {
96418       {
96419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96420       };
96421     } catch (...) {
96422       {
96423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96424       };
96425     }
96426   }
96427   jresult = (void *)result;
96428   return jresult;
96429 }
96430
96431
96432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
96433   void * jresult ;
96434   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96435   Dali::WidgetApplication *arg2 = 0 ;
96436   Dali::WidgetApplication *result = 0 ;
96437
96438   arg1 = (Dali::WidgetApplication *)jarg1;
96439   arg2 = (Dali::WidgetApplication *)jarg2;
96440   if (!arg2) {
96441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96442     return 0;
96443   }
96444   {
96445     try {
96446       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
96447     } catch (std::out_of_range& e) {
96448       {
96449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96450       };
96451     } catch (std::exception& e) {
96452       {
96453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96454       };
96455     } catch (...) {
96456       {
96457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96458       };
96459     }
96460   }
96461   jresult = (void *)result;
96462   return jresult;
96463 }
96464
96465
96466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
96467   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96468
96469   arg1 = (Dali::WidgetApplication *)jarg1;
96470   {
96471     try {
96472       delete arg1;
96473       if( argWidgetV )
96474       {
96475         // free string data
96476         for( int i=0; i < argWidgetC+1; i++)
96477         {
96478           delete [] argWidgetV[i];
96479         }
96480         delete [] argWidgetV;
96481       }
96482     } catch (std::out_of_range& e) {
96483       {
96484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96485       };
96486     } catch (std::exception& e) {
96487       {
96488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96489       };
96490     } catch (...) {
96491       {
96492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96493       };
96494     }
96495   }
96496 }
96497
96498
96499 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
96500 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
96501
96502 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
96503 {
96504   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
96505   return *widget;
96506 }
96507
96508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
96509   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96510   std::string *arg2 = 0 ;
96511
96512   arg1 = (Dali::WidgetApplication *)jarg1;
96513   if (!jarg2) {
96514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96515     return ;
96516   }
96517   std::string arg2_str(*jarg2);
96518   arg2 = &arg2_str;
96519
96520   if(!_CSharpCreateWidgetFunction)
96521   {
96522     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
96523   }
96524
96525   {
96526     try {
96527       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
96528     } catch (std::out_of_range& e) {
96529       {
96530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96531       };
96532     } catch (std::exception& e) {
96533       {
96534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96535       };
96536     } catch (...) {
96537       {
96538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96539       };
96540     }
96541   }
96542
96543   //Typemap argout in c++ file.
96544   //This will convert c++ string to c# string
96545   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
96546 }
96547
96548
96549 //for PixelBuffer and ImageLoading
96550
96551 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
96552     return (Dali::BaseHandle *)jarg1;
96553 }
96554
96555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
96556   void * jresult ;
96557   unsigned int arg1 ;
96558   unsigned int arg2 ;
96559   Dali::Pixel::Format arg3 ;
96560   Dali::Devel::PixelBuffer result;
96561
96562   arg1 = (unsigned int)jarg1;
96563   arg2 = (unsigned int)jarg2;
96564   arg3 = (Dali::Pixel::Format)jarg3;
96565   {
96566     try {
96567       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
96568     } catch (std::out_of_range& e) {
96569       {
96570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96571       };
96572     } catch (std::exception& e) {
96573       {
96574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96575       };
96576     } catch (...) {
96577       {
96578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96579       };
96580     }
96581   }
96582   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
96583   return jresult;
96584 }
96585
96586
96587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
96588   void * jresult ;
96589   Dali::Devel::PixelBuffer *result = 0 ;
96590
96591   {
96592     try {
96593       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
96594     } catch (std::out_of_range& e) {
96595       {
96596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96597       };
96598     } catch (std::exception& e) {
96599       {
96600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96601       };
96602     } catch (...) {
96603       {
96604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96605       };
96606     }
96607   }
96608   jresult = (void *)result;
96609   return jresult;
96610 }
96611
96612
96613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
96614   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96615
96616   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96617   {
96618     try {
96619       delete arg1;
96620     } catch (std::out_of_range& e) {
96621       {
96622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96623       };
96624     } catch (std::exception& e) {
96625       {
96626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96627       };
96628     } catch (...) {
96629       {
96630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96631       };
96632     }
96633   }
96634 }
96635
96636
96637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
96638   void * jresult ;
96639   Dali::Devel::PixelBuffer *arg1 = 0 ;
96640   Dali::Devel::PixelBuffer *result = 0 ;
96641
96642   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96643   if (!arg1) {
96644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
96645     return 0;
96646   }
96647   {
96648     try {
96649       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
96650     } catch (std::out_of_range& e) {
96651       {
96652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96653       };
96654     } catch (std::exception& e) {
96655       {
96656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96657       };
96658     } catch (...) {
96659       {
96660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96661       };
96662     }
96663   }
96664   jresult = (void *)result;
96665   return jresult;
96666 }
96667
96668
96669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
96670   void * jresult ;
96671   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96672   Dali::Devel::PixelBuffer *arg2 = 0 ;
96673   Dali::Devel::PixelBuffer *result = 0 ;
96674
96675   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96676   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
96677   if (!arg2) {
96678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
96679     return 0;
96680   }
96681   {
96682     try {
96683       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
96684     } catch (std::out_of_range& e) {
96685       {
96686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96687       };
96688     } catch (std::exception& e) {
96689       {
96690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96691       };
96692     } catch (...) {
96693       {
96694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96695       };
96696     }
96697   }
96698   jresult = (void *)result;
96699   return jresult;
96700 }
96701
96702
96703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
96704   void * jresult ;
96705   Dali::Devel::PixelBuffer *arg1 = 0 ;
96706   Dali::PixelData result;
96707
96708   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96709   if (!arg1) {
96710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
96711     return 0;
96712   }
96713   {
96714     try {
96715       result = Dali::Devel::PixelBuffer::Convert(*arg1);
96716     } catch (std::out_of_range& e) {
96717       {
96718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96719       };
96720     } catch (std::exception& e) {
96721       {
96722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96723       };
96724     } catch (...) {
96725       {
96726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96727       };
96728     }
96729   }
96730   jresult = new Dali::PixelData((const Dali::PixelData &)result);
96731   return jresult;
96732 }
96733
96734
96735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
96736   void * jresult ;
96737   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96738   Dali::PixelData result;
96739
96740   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96741   {
96742     try {
96743       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
96744     } catch (std::out_of_range& e) {
96745       {
96746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96747       };
96748     } catch (std::exception& e) {
96749       {
96750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96751       };
96752     } catch (...) {
96753       {
96754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96755       };
96756     }
96757   }
96758   jresult = new Dali::PixelData((const Dali::PixelData &)result);
96759   return jresult;
96760 }
96761
96762
96763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
96764   void * jresult ;
96765   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96766   unsigned char *result = 0 ;
96767
96768   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96769   {
96770     try {
96771       result = (unsigned char *)(arg1)->GetBuffer();
96772     } catch (std::out_of_range& e) {
96773       {
96774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96775       };
96776     } catch (std::exception& e) {
96777       {
96778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96779       };
96780     } catch (...) {
96781       {
96782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96783       };
96784     }
96785   }
96786   jresult = (void *)result;
96787   return jresult;
96788 }
96789
96790
96791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
96792   unsigned int jresult ;
96793   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96794   unsigned int result;
96795
96796   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96797   {
96798     try {
96799       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
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 = result;
96815   return jresult;
96816 }
96817
96818
96819 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
96820   unsigned int jresult ;
96821   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96822   unsigned int result;
96823
96824   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96825   {
96826     try {
96827       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
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 = result;
96843   return jresult;
96844 }
96845
96846
96847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
96848   int jresult ;
96849   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96850   Dali::Pixel::Format result;
96851
96852   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96853   {
96854     try {
96855       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
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 = (int)result;
96871   return jresult;
96872 }
96873
96874
96875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
96876   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96877   Dali::Devel::PixelBuffer arg2 ;
96878   float arg3 ;
96879   bool arg4 ;
96880   Dali::Devel::PixelBuffer *argp2 ;
96881
96882   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96883   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
96884   if (!argp2) {
96885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
96886     return ;
96887   }
96888   arg2 = *argp2;
96889   arg3 = (float)jarg3;
96890   arg4 = jarg4 ? true : false;
96891   {
96892     try {
96893       (arg1)->ApplyMask(arg2,arg3,arg4);
96894     } catch (std::out_of_range& e) {
96895       {
96896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96897       };
96898     } catch (std::exception& e) {
96899       {
96900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96901       };
96902     } catch (...) {
96903       {
96904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96905       };
96906     }
96907   }
96908 }
96909
96910
96911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
96912   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96913   Dali::Devel::PixelBuffer arg2 ;
96914   float arg3 ;
96915   Dali::Devel::PixelBuffer *argp2 ;
96916
96917   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96918   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
96919   if (!argp2) {
96920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
96921     return ;
96922   }
96923   arg2 = *argp2;
96924   arg3 = (float)jarg3;
96925   {
96926     try {
96927       (arg1)->ApplyMask(arg2,arg3);
96928     } catch (std::out_of_range& e) {
96929       {
96930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96931       };
96932     } catch (std::exception& e) {
96933       {
96934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96935       };
96936     } catch (...) {
96937       {
96938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96939       };
96940     }
96941   }
96942 }
96943
96944
96945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
96946   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96947   Dali::Devel::PixelBuffer arg2 ;
96948   Dali::Devel::PixelBuffer *argp2 ;
96949
96950   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96951   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
96952   if (!argp2) {
96953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
96954     return ;
96955   }
96956   arg2 = *argp2;
96957   {
96958     try {
96959       (arg1)->ApplyMask(arg2);
96960     } catch (std::out_of_range& e) {
96961       {
96962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96963       };
96964     } catch (std::exception& e) {
96965       {
96966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96967       };
96968     } catch (...) {
96969       {
96970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96971       };
96972     }
96973   }
96974 }
96975
96976
96977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
96978   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96979   float arg2 ;
96980
96981   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96982   arg2 = (float)jarg2;
96983   {
96984     try {
96985       (arg1)->ApplyGaussianBlur(arg2);
96986     } catch (std::out_of_range& e) {
96987       {
96988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96989       };
96990     } catch (std::exception& e) {
96991       {
96992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96993       };
96994     } catch (...) {
96995       {
96996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96997       };
96998     }
96999   }
97000 }
97001
97002
97003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
97004   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97005   uint16_t arg2 ;
97006   uint16_t arg3 ;
97007   uint16_t arg4 ;
97008   uint16_t arg5 ;
97009
97010   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97011   arg2 = (uint16_t)jarg2;
97012   arg3 = (uint16_t)jarg3;
97013   arg4 = (uint16_t)jarg4;
97014   arg5 = (uint16_t)jarg5;
97015   {
97016     try {
97017       (arg1)->Crop(arg2,arg3,arg4,arg5);
97018     } catch (std::out_of_range& e) {
97019       {
97020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97021       };
97022     } catch (std::exception& e) {
97023       {
97024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97025       };
97026     } catch (...) {
97027       {
97028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97029       };
97030     }
97031   }
97032 }
97033
97034
97035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
97036   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97037   uint16_t arg2 ;
97038   uint16_t arg3 ;
97039
97040   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97041   arg2 = (uint16_t)jarg2;
97042   arg3 = (uint16_t)jarg3;
97043   {
97044     try {
97045       (arg1)->Resize(arg2,arg3);
97046     } catch (std::out_of_range& e) {
97047       {
97048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97049       };
97050     } catch (std::exception& e) {
97051       {
97052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97053       };
97054     } catch (...) {
97055       {
97056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97057       };
97058     }
97059   }
97060 }
97061
97062 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void * jarg2) {
97063   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97064   Dali::Degree * arg2 ;
97065
97066   bool result = false;
97067
97068   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97069   arg2 = (Dali::Degree *)jarg2;
97070   {
97071     try {
97072       result = (arg1)->Rotate(*arg2);
97073     } catch (std::out_of_range& e) {
97074       {
97075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
97076       };
97077     } catch (std::exception& e) {
97078       {
97079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
97080       };
97081     } catch (...) {
97082       {
97083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
97084       };
97085     }
97086   }
97087   return result;
97088 }
97089
97090
97091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97092   void * jresult ;
97093   std::string *arg1 = 0 ;
97094   Dali::ImageDimensions arg2 ;
97095   Dali::FittingMode::Type arg3 ;
97096   Dali::SamplingMode::Type arg4 ;
97097   bool arg5 ;
97098   Dali::ImageDimensions *argp2 ;
97099   Dali::Devel::PixelBuffer result;
97100
97101   if (!jarg1) {
97102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97103     return 0;
97104   }
97105   std::string arg1_str(jarg1);
97106   arg1 = &arg1_str;
97107   argp2 = (Dali::ImageDimensions *)jarg2;
97108   if (!argp2) {
97109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97110     return 0;
97111   }
97112   arg2 = *argp2;
97113   arg3 = (Dali::FittingMode::Type)jarg3;
97114   arg4 = (Dali::SamplingMode::Type)jarg4;
97115   arg5 = jarg5 ? true : false;
97116   {
97117     try {
97118       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97119     } catch (std::out_of_range& e) {
97120       {
97121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97122       };
97123     } catch (std::exception& e) {
97124       {
97125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97126       };
97127     } catch (...) {
97128       {
97129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97130       };
97131     }
97132   }
97133   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97134
97135   return jresult;
97136 }
97137
97138
97139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97140   void * jresult ;
97141   std::string *arg1 = 0 ;
97142   Dali::ImageDimensions arg2 ;
97143   Dali::FittingMode::Type arg3 ;
97144   Dali::SamplingMode::Type arg4 ;
97145   Dali::ImageDimensions *argp2 ;
97146   Dali::Devel::PixelBuffer result;
97147
97148   if (!jarg1) {
97149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97150     return 0;
97151   }
97152   std::string arg1_str(jarg1);
97153   arg1 = &arg1_str;
97154   argp2 = (Dali::ImageDimensions *)jarg2;
97155   if (!argp2) {
97156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97157     return 0;
97158   }
97159   arg2 = *argp2;
97160   arg3 = (Dali::FittingMode::Type)jarg3;
97161   arg4 = (Dali::SamplingMode::Type)jarg4;
97162   {
97163     try {
97164       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
97165     } catch (std::out_of_range& e) {
97166       {
97167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97168       };
97169     } catch (std::exception& e) {
97170       {
97171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97172       };
97173     } catch (...) {
97174       {
97175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97176       };
97177     }
97178   }
97179   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97180
97181   return jresult;
97182 }
97183
97184
97185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97186   void * jresult ;
97187   std::string *arg1 = 0 ;
97188   Dali::ImageDimensions arg2 ;
97189   Dali::FittingMode::Type arg3 ;
97190   Dali::ImageDimensions *argp2 ;
97191   Dali::Devel::PixelBuffer result;
97192
97193   if (!jarg1) {
97194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97195     return 0;
97196   }
97197   std::string arg1_str(jarg1);
97198   arg1 = &arg1_str;
97199   argp2 = (Dali::ImageDimensions *)jarg2;
97200   if (!argp2) {
97201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97202     return 0;
97203   }
97204   arg2 = *argp2;
97205   arg3 = (Dali::FittingMode::Type)jarg3;
97206   {
97207     try {
97208       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
97209     } catch (std::out_of_range& e) {
97210       {
97211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97212       };
97213     } catch (std::exception& e) {
97214       {
97215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97216       };
97217     } catch (...) {
97218       {
97219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97220       };
97221     }
97222   }
97223   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97224
97225   return jresult;
97226 }
97227
97228
97229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
97230   void * jresult ;
97231   std::string *arg1 = 0 ;
97232   Dali::ImageDimensions arg2 ;
97233   Dali::ImageDimensions *argp2 ;
97234   Dali::Devel::PixelBuffer result;
97235
97236   if (!jarg1) {
97237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97238     return 0;
97239   }
97240   std::string arg1_str(jarg1);
97241   arg1 = &arg1_str;
97242   argp2 = (Dali::ImageDimensions *)jarg2;
97243   if (!argp2) {
97244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97245     return 0;
97246   }
97247   arg2 = *argp2;
97248   {
97249     try {
97250       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
97251     } catch (std::out_of_range& e) {
97252       {
97253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97254       };
97255     } catch (std::exception& e) {
97256       {
97257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97258       };
97259     } catch (...) {
97260       {
97261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97262       };
97263     }
97264   }
97265   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97266
97267   return jresult;
97268 }
97269
97270
97271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
97272   void * jresult ;
97273   std::string *arg1 = 0 ;
97274   Dali::Devel::PixelBuffer result;
97275
97276   if (!jarg1) {
97277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97278     return 0;
97279   }
97280   std::string arg1_str(jarg1);
97281   arg1 = &arg1_str;
97282   {
97283     try {
97284       result = Dali::LoadImageFromFile((std::string const &)*arg1);
97285     } catch (std::out_of_range& e) {
97286       {
97287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97288       };
97289     } catch (std::exception& e) {
97290       {
97291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97292       };
97293     } catch (...) {
97294       {
97295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97296       };
97297     }
97298   }
97299   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97300
97301   return jresult;
97302 }
97303
97304
97305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97306   void * jresult ;
97307   std::string *arg1 = 0 ;
97308   Dali::ImageDimensions arg2 ;
97309   Dali::FittingMode::Type arg3 ;
97310   Dali::SamplingMode::Type arg4 ;
97311   bool arg5 ;
97312   Dali::ImageDimensions *argp2 ;
97313   Dali::ImageDimensions result;
97314
97315   if (!jarg1) {
97316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97317     return 0;
97318   }
97319   std::string arg1_str(jarg1);
97320   arg1 = &arg1_str;
97321   argp2 = (Dali::ImageDimensions *)jarg2;
97322   if (!argp2) {
97323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97324     return 0;
97325   }
97326   arg2 = *argp2;
97327   arg3 = (Dali::FittingMode::Type)jarg3;
97328   arg4 = (Dali::SamplingMode::Type)jarg4;
97329   arg5 = jarg5 ? true : false;
97330   {
97331     try {
97332       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97333     } catch (std::out_of_range& e) {
97334       {
97335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97336       };
97337     } catch (std::exception& e) {
97338       {
97339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97340       };
97341     } catch (...) {
97342       {
97343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97344       };
97345     }
97346   }
97347   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97348
97349   return jresult;
97350 }
97351
97352
97353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97354   void * jresult ;
97355   std::string *arg1 = 0 ;
97356   Dali::ImageDimensions arg2 ;
97357   Dali::FittingMode::Type arg3 ;
97358   Dali::SamplingMode::Type arg4 ;
97359   Dali::ImageDimensions *argp2 ;
97360   Dali::ImageDimensions result;
97361
97362   if (!jarg1) {
97363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97364     return 0;
97365   }
97366   std::string arg1_str(jarg1);
97367   arg1 = &arg1_str;
97368   argp2 = (Dali::ImageDimensions *)jarg2;
97369   if (!argp2) {
97370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97371     return 0;
97372   }
97373   arg2 = *argp2;
97374   arg3 = (Dali::FittingMode::Type)jarg3;
97375   arg4 = (Dali::SamplingMode::Type)jarg4;
97376   {
97377     try {
97378       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
97379     } catch (std::out_of_range& e) {
97380       {
97381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97382       };
97383     } catch (std::exception& e) {
97384       {
97385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97386       };
97387     } catch (...) {
97388       {
97389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97390       };
97391     }
97392   }
97393   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97394
97395   return jresult;
97396 }
97397
97398
97399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97400   void * jresult ;
97401   std::string *arg1 = 0 ;
97402   Dali::ImageDimensions arg2 ;
97403   Dali::FittingMode::Type arg3 ;
97404   Dali::ImageDimensions *argp2 ;
97405   Dali::ImageDimensions result;
97406
97407   if (!jarg1) {
97408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97409     return 0;
97410   }
97411   std::string arg1_str(jarg1);
97412   arg1 = &arg1_str;
97413   argp2 = (Dali::ImageDimensions *)jarg2;
97414   if (!argp2) {
97415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97416     return 0;
97417   }
97418   arg2 = *argp2;
97419   arg3 = (Dali::FittingMode::Type)jarg3;
97420   {
97421     try {
97422       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
97423     } catch (std::out_of_range& e) {
97424       {
97425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97426       };
97427     } catch (std::exception& e) {
97428       {
97429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97430       };
97431     } catch (...) {
97432       {
97433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97434       };
97435     }
97436   }
97437   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97438
97439   return jresult;
97440 }
97441
97442
97443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
97444   void * jresult ;
97445   std::string *arg1 = 0 ;
97446   Dali::ImageDimensions arg2 ;
97447   Dali::ImageDimensions *argp2 ;
97448   Dali::ImageDimensions result;
97449
97450   if (!jarg1) {
97451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97452     return 0;
97453   }
97454   std::string arg1_str(jarg1);
97455   arg1 = &arg1_str;
97456   argp2 = (Dali::ImageDimensions *)jarg2;
97457   if (!argp2) {
97458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97459     return 0;
97460   }
97461   arg2 = *argp2;
97462   {
97463     try {
97464       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
97465     } catch (std::out_of_range& e) {
97466       {
97467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97468       };
97469     } catch (std::exception& e) {
97470       {
97471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97472       };
97473     } catch (...) {
97474       {
97475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97476       };
97477     }
97478   }
97479   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97480
97481   return jresult;
97482 }
97483
97484
97485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
97486   void * jresult ;
97487   std::string *arg1 = 0 ;
97488   Dali::ImageDimensions result;
97489
97490   if (!jarg1) {
97491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97492     return 0;
97493   }
97494   std::string arg1_str(jarg1);
97495   arg1 = &arg1_str;
97496   {
97497     try {
97498       result = Dali::GetClosestImageSize((std::string const &)*arg1);
97499     } catch (std::out_of_range& e) {
97500       {
97501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97502       };
97503     } catch (std::exception& e) {
97504       {
97505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97506       };
97507     } catch (...) {
97508       {
97509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97510       };
97511     }
97512   }
97513   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97514
97515   return jresult;
97516 }
97517
97518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
97519   void * jresult ;
97520   std::string *arg1 = 0 ;
97521   Dali::ImageDimensions result;
97522
97523   if (!jarg1) {
97524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97525     return 0;
97526   }
97527   std::string arg1_str(jarg1);
97528   arg1 = &arg1_str;
97529   {
97530     try {
97531       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
97532     } catch (std::out_of_range& e) {
97533       {
97534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97535       };
97536     } catch (std::exception& e) {
97537       {
97538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97539       };
97540     } catch (...) {
97541       {
97542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97543       };
97544     }
97545   }
97546   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97547
97548   return jresult;
97549 }
97550
97551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97552   void * jresult ;
97553   std::string *arg1 = 0 ;
97554   Dali::ImageDimensions arg2 ;
97555   Dali::FittingMode::Type arg3 ;
97556   Dali::SamplingMode::Type arg4 ;
97557   bool arg5 ;
97558   Dali::ImageDimensions *argp2 ;
97559   Dali::Devel::PixelBuffer result;
97560
97561   if (!jarg1) {
97562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97563     return 0;
97564   }
97565   std::string arg1_str(jarg1);
97566   arg1 = &arg1_str;
97567   argp2 = (Dali::ImageDimensions *)jarg2;
97568   if (!argp2) {
97569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97570     return 0;
97571   }
97572   arg2 = *argp2;
97573   arg3 = (Dali::FittingMode::Type)jarg3;
97574   arg4 = (Dali::SamplingMode::Type)jarg4;
97575   arg5 = jarg5 ? true : false;
97576   {
97577     try {
97578       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97579     } catch (std::out_of_range& e) {
97580       {
97581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97582       };
97583     } catch (std::exception& e) {
97584       {
97585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97586       };
97587     } catch (...) {
97588       {
97589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97590       };
97591     }
97592   }
97593   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97594
97595   return jresult;
97596 }
97597
97598
97599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97600   void * jresult ;
97601   std::string *arg1 = 0 ;
97602   Dali::ImageDimensions arg2 ;
97603   Dali::FittingMode::Type arg3 ;
97604   Dali::SamplingMode::Type arg4 ;
97605   Dali::ImageDimensions *argp2 ;
97606   Dali::Devel::PixelBuffer result;
97607
97608   if (!jarg1) {
97609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97610     return 0;
97611   }
97612   std::string arg1_str(jarg1);
97613   arg1 = &arg1_str;
97614   argp2 = (Dali::ImageDimensions *)jarg2;
97615   if (!argp2) {
97616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97617     return 0;
97618   }
97619   arg2 = *argp2;
97620   arg3 = (Dali::FittingMode::Type)jarg3;
97621   arg4 = (Dali::SamplingMode::Type)jarg4;
97622   {
97623     try {
97624       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
97625     } catch (std::out_of_range& e) {
97626       {
97627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97628       };
97629     } catch (std::exception& e) {
97630       {
97631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97632       };
97633     } catch (...) {
97634       {
97635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97636       };
97637     }
97638   }
97639   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97640
97641   return jresult;
97642 }
97643
97644
97645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97646   void * jresult ;
97647   std::string *arg1 = 0 ;
97648   Dali::ImageDimensions arg2 ;
97649   Dali::FittingMode::Type arg3 ;
97650   Dali::ImageDimensions *argp2 ;
97651   Dali::Devel::PixelBuffer result;
97652
97653   if (!jarg1) {
97654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97655     return 0;
97656   }
97657   std::string arg1_str(jarg1);
97658   arg1 = &arg1_str;
97659   argp2 = (Dali::ImageDimensions *)jarg2;
97660   if (!argp2) {
97661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97662     return 0;
97663   }
97664   arg2 = *argp2;
97665   arg3 = (Dali::FittingMode::Type)jarg3;
97666   {
97667     try {
97668       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
97669     } catch (std::out_of_range& e) {
97670       {
97671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97672       };
97673     } catch (std::exception& e) {
97674       {
97675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97676       };
97677     } catch (...) {
97678       {
97679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97680       };
97681     }
97682   }
97683   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97684
97685   return jresult;
97686 }
97687
97688
97689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
97690   void * jresult ;
97691   std::string *arg1 = 0 ;
97692   Dali::ImageDimensions arg2 ;
97693   Dali::ImageDimensions *argp2 ;
97694   Dali::Devel::PixelBuffer result;
97695
97696   if (!jarg1) {
97697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97698     return 0;
97699   }
97700   std::string arg1_str(jarg1);
97701   arg1 = &arg1_str;
97702   argp2 = (Dali::ImageDimensions *)jarg2;
97703   if (!argp2) {
97704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97705     return 0;
97706   }
97707   arg2 = *argp2;
97708   {
97709     try {
97710       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
97711     } catch (std::out_of_range& e) {
97712       {
97713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97714       };
97715     } catch (std::exception& e) {
97716       {
97717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97718       };
97719     } catch (...) {
97720       {
97721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97722       };
97723     }
97724   }
97725   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97726
97727   return jresult;
97728 }
97729
97730
97731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
97732   void * jresult ;
97733   std::string *arg1 = 0 ;
97734   Dali::Devel::PixelBuffer result;
97735
97736   if (!jarg1) {
97737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97738     return 0;
97739   }
97740   std::string arg1_str(jarg1);
97741   arg1 = &arg1_str;
97742   {
97743     try {
97744       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
97745     } catch (std::out_of_range& e) {
97746       {
97747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97748       };
97749     } catch (std::exception& e) {
97750       {
97751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97752       };
97753     } catch (...) {
97754       {
97755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97756       };
97757     }
97758   }
97759   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97760
97761   return jresult;
97762 }
97763
97764
97765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
97766   void * jresult ;
97767   Dali::Toolkit::WebView result;
97768
97769   {
97770     try {
97771       result = Dali::Toolkit::WebView::New();
97772     } catch (std::out_of_range& e) {
97773       {
97774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97775       };
97776     } catch (std::exception& e) {
97777       {
97778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97779       };
97780     } catch (Dali::DaliException e) {
97781       {
97782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97783       };
97784     } catch (...) {
97785       {
97786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97787       };
97788     }
97789   }
97790   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
97791   return jresult;
97792 }
97793
97794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
97795   void * jresult ;
97796   Dali::Toolkit::WebView result;
97797
97798   std::string *arg1;
97799   std::string *arg2;
97800
97801   if (!jarg1) {
97802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
97803     return 0;
97804   }
97805   if (!jarg2) {
97806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
97807     return 0;
97808   }
97809
97810   std::string jarg1_str = std::string(jarg1);
97811   std::string jarg2_str = std::string(jarg2);
97812
97813   arg1 = &jarg1_str;
97814   arg2 = &jarg2_str;
97815
97816   {
97817     try {
97818       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
97819     } catch (std::out_of_range& e) {
97820       {
97821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97822       };
97823     } catch (std::exception& e) {
97824       {
97825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97826       };
97827     } catch (Dali::DaliException e) {
97828       {
97829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97830       };
97831     } catch (...) {
97832       {
97833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97834       };
97835     }
97836   }
97837   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
97838   return jresult;
97839 }
97840
97841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
97842   void * jresult ;
97843   Dali::Toolkit::WebView *arg1 = 0 ;
97844   Dali::Toolkit::WebView *result = 0 ;
97845
97846   arg1 = (Dali::Toolkit::WebView *)jarg1;
97847   if (!arg1) {
97848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
97849     return 0;
97850   }
97851   {
97852     try {
97853       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
97854     } catch (std::out_of_range& e) {
97855       {
97856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97857       };
97858     } catch (std::exception& e) {
97859       {
97860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97861       };
97862     } catch (Dali::DaliException e) {
97863       {
97864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97865       };
97866     } catch (...) {
97867       {
97868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97869       };
97870     }
97871   }
97872   jresult = (void *)result;
97873   return jresult;
97874 }
97875
97876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
97877   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
97878   arg1 = (Dali::Toolkit::WebView *)jarg1;
97879   {
97880     try {
97881       delete arg1;
97882     } catch (std::out_of_range& e) {
97883       {
97884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97885       };
97886     } catch (std::exception& e) {
97887       {
97888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97889       };
97890     } catch (Dali::DaliException e) {
97891       {
97892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97893       };
97894     } catch (...) {
97895       {
97896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97897       };
97898     }
97899   }
97900 }
97901
97902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
97903   void * jresult ;
97904   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
97905   Dali::Toolkit::WebView *arg2 = 0 ;
97906   Dali::Toolkit::WebView *result = 0 ;
97907
97908   arg1 = (Dali::Toolkit::WebView *)jarg1;
97909   arg2 = (Dali::Toolkit::WebView *)jarg2;
97910   if (!arg2) {
97911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
97912     return 0;
97913   }
97914   {
97915     try {
97916       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
97917     } catch (std::out_of_range& e) {
97918       {
97919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97920       };
97921     } catch (std::exception& e) {
97922       {
97923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97924       };
97925     } catch (Dali::DaliException e) {
97926       {
97927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97928       };
97929     } catch (...) {
97930       {
97931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97932       };
97933     }
97934   }
97935   jresult = (void *)result;
97936   return jresult;
97937 }
97938
97939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
97940   void * jresult ;
97941   Dali::BaseHandle arg1 ;
97942   Dali::BaseHandle *argp1 ;
97943   Dali::Toolkit::WebView result;
97944
97945   argp1 = (Dali::BaseHandle *)jarg1;
97946   if (!argp1) {
97947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
97948     return 0;
97949   }
97950   arg1 = *argp1;
97951   {
97952     try {
97953       result = Dali::Toolkit::WebView::DownCast(arg1);
97954     } catch (std::out_of_range& e) {
97955       {
97956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97957       };
97958     } catch (std::exception& e) {
97959       {
97960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97961       };
97962     } catch (Dali::DaliException e) {
97963       {
97964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97965       };
97966     } catch (...) {
97967       {
97968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97969       };
97970     }
97971   }
97972   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
97973   return jresult;
97974 }
97975
97976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
97977   return (int) Dali::Toolkit::WebView::Property::URL;
97978 }
97979
97980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
97981   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
97982 }
97983
97984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
97985   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
97986 }
97987
97988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
97989   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
97990 }
97991
97992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
97993   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
97994 }
97995
97996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
97997   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
97998 }
97999
98000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
98001   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
98002 }
98003
98004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
98005   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
98006 }
98007
98008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
98009   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98010   std::string *arg2;
98011
98012   arg1 = (Dali::Toolkit::WebView *)jarg1;
98013
98014   if (!jarg2) {
98015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98016     return;
98017   }
98018
98019   std::string jarg2str = std::string(jarg2);
98020   arg2 = &jarg2str;
98021   {
98022     try {
98023       (arg1)->LoadUrl((std::string const &)*arg2);
98024     } catch (std::out_of_range& e) {
98025       {
98026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98027       };
98028     } catch (std::exception& e) {
98029       {
98030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98031       };
98032     } catch (Dali::DaliException e) {
98033       {
98034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98035       };
98036     } catch (...) {
98037       {
98038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98039       };
98040     }
98041   }
98042 }
98043
98044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
98045   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98046   std::string *arg2;
98047
98048   arg1 = (Dali::Toolkit::WebView *)jarg1;
98049   if (!jarg2) {
98050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98051     return;
98052   }
98053   std::string jarg2str = std::string(jarg2);
98054   arg2 = &jarg2str;
98055   {
98056     try {
98057       (arg1)->LoadHTMLString((std::string const &)*arg2);
98058     } catch (std::out_of_range& e) {
98059       {
98060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98061       };
98062     } catch (std::exception& e) {
98063       {
98064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98065       };
98066     } catch (Dali::DaliException e) {
98067       {
98068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98069       };
98070     } catch (...) {
98071       {
98072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98073       };
98074     }
98075   }
98076 }
98077
98078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
98079   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98080
98081   arg1 = (Dali::Toolkit::WebView *)jarg1;
98082   {
98083     try {
98084       (arg1)->Reload();
98085     } catch (std::out_of_range& e) {
98086       {
98087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98088       };
98089     } catch (std::exception& e) {
98090       {
98091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98092       };
98093     } catch (Dali::DaliException e) {
98094       {
98095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98096       };
98097     } catch (...) {
98098       {
98099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98100       };
98101     }
98102   }
98103 }
98104
98105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
98106   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98107
98108   arg1 = (Dali::Toolkit::WebView *)jarg1;
98109   {
98110     try {
98111       (arg1)->StopLoading();
98112     } catch (std::out_of_range& e) {
98113       {
98114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98115       };
98116     } catch (std::exception& e) {
98117       {
98118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98119       };
98120     } catch (Dali::DaliException e) {
98121       {
98122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98123       };
98124     } catch (...) {
98125       {
98126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98127       };
98128     }
98129   }
98130 }
98131
98132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
98133   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98134
98135   arg1 = (Dali::Toolkit::WebView *)jarg1;
98136   {
98137     try {
98138       (arg1)->Suspend();
98139     } catch (std::out_of_range& e) {
98140       {
98141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98142       };
98143     } catch (std::exception& e) {
98144       {
98145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98146       };
98147     } catch (Dali::DaliException e) {
98148       {
98149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98150       };
98151     } catch (...) {
98152       {
98153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98154       };
98155     }
98156   }
98157 }
98158
98159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
98160   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98161
98162   arg1 = (Dali::Toolkit::WebView *)jarg1;
98163   {
98164     try {
98165       (arg1)->Resume();
98166     } catch (std::out_of_range& e) {
98167       {
98168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98169       };
98170     } catch (std::exception& e) {
98171       {
98172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98173       };
98174     } catch (Dali::DaliException e) {
98175       {
98176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98177       };
98178     } catch (...) {
98179       {
98180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98181       };
98182     }
98183   }
98184 }
98185
98186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
98187   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98188
98189   arg1 = (Dali::Toolkit::WebView *)jarg1;
98190   {
98191     try {
98192       (arg1)->GoBack();
98193     } catch (std::out_of_range& e) {
98194       {
98195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98196       };
98197     } catch (std::exception& e) {
98198       {
98199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98200       };
98201     } catch (Dali::DaliException e) {
98202       {
98203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98204       };
98205     } catch (...) {
98206       {
98207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98208       };
98209     }
98210   }
98211 }
98212
98213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
98214   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98215
98216   arg1 = (Dali::Toolkit::WebView *)jarg1;
98217   {
98218     try {
98219       (arg1)->GoForward();
98220     } catch (std::out_of_range& e) {
98221       {
98222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98223       };
98224     } catch (std::exception& e) {
98225       {
98226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98227       };
98228     } catch (Dali::DaliException e) {
98229       {
98230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98231       };
98232     } catch (...) {
98233       {
98234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98235       };
98236     }
98237   }
98238 }
98239
98240 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
98241   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98242   bool ret;
98243
98244   arg1 = (Dali::Toolkit::WebView *)jarg1;
98245   {
98246     try {
98247       ret = (arg1)->CanGoBack();
98248     } catch (std::out_of_range& e) {
98249       {
98250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98251       };
98252     } catch (std::exception& e) {
98253       {
98254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98255       };
98256     } catch (Dali::DaliException e) {
98257       {
98258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98259       };
98260     } catch (...) {
98261       {
98262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98263       };
98264     }
98265   }
98266   return ret;
98267 }
98268
98269 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
98270   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98271   bool ret;
98272
98273   arg1 = (Dali::Toolkit::WebView *)jarg1;
98274   {
98275     try {
98276       ret = (arg1)->CanGoForward();
98277     } catch (std::out_of_range& e) {
98278       {
98279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98280       };
98281     } catch (std::exception& e) {
98282       {
98283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98284       };
98285     } catch (Dali::DaliException e) {
98286       {
98287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98288       };
98289     } catch (...) {
98290       {
98291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98292       };
98293     }
98294   }
98295   return ret;
98296 }
98297
98298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
98299   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98300   std::string *arg2;
98301
98302   arg1 = (Dali::Toolkit::WebView *)jarg1;
98303   if (!jarg2) {
98304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98305     return;
98306   }
98307   std::string jarg2_str = std::string(jarg2);
98308   arg2 = &jarg2_str;
98309
98310   {
98311     try {
98312       if (jarg3) {
98313         void (*handler)(char*) = (void (*)(char*)) jarg3;
98314         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
98315           handler(SWIG_csharp_string_callback(result.c_str()));
98316         });
98317       } else {
98318         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
98319       }
98320     } catch (std::out_of_range& e) {
98321       {
98322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98323       };
98324     } catch (std::exception& e) {
98325       {
98326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98327       };
98328     } catch (Dali::DaliException e) {
98329       {
98330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98331       };
98332     } catch (...) {
98333       {
98334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98335       };
98336     }
98337   }
98338 }
98339
98340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
98341 {
98342   if (!jarg2) {
98343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98344     return;
98345   }
98346
98347   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98348   std::string exposedObjectName = jarg2;
98349   void (*handler)(char*) = (void (*)(char*)) jarg3;
98350
98351   {
98352     try {
98353       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
98354         handler(SWIG_csharp_string_callback(message.c_str()));
98355       });
98356     } catch (std::out_of_range& e) {
98357       {
98358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98359       };
98360     } catch (std::exception& e) {
98361       {
98362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98363       };
98364     } catch (Dali::DaliException e) {
98365       {
98366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98367       };
98368     } catch (...) {
98369       {
98370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98371       };
98372     }
98373   }
98374 }
98375
98376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
98377   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98378
98379   arg1 = (Dali::Toolkit::WebView *)jarg1;
98380   {
98381     try {
98382       (arg1)->ClearHistory();
98383     } catch (std::out_of_range& e) {
98384       {
98385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98386       };
98387     } catch (std::exception& e) {
98388       {
98389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98390       };
98391     } catch (Dali::DaliException e) {
98392       {
98393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98394       };
98395     } catch (...) {
98396       {
98397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98398       };
98399     }
98400   }
98401 }
98402
98403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
98404   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98405
98406   arg1 = (Dali::Toolkit::WebView *)jarg1;
98407   {
98408     try {
98409       (arg1)->ClearCache();
98410     } catch (std::out_of_range& e) {
98411       {
98412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98413       };
98414     } catch (std::exception& e) {
98415       {
98416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98417       };
98418     } catch (Dali::DaliException e) {
98419       {
98420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98421       };
98422     } catch (...) {
98423       {
98424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98425       };
98426     }
98427   }
98428 }
98429
98430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
98431   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98432
98433   arg1 = (Dali::Toolkit::WebView *)jarg1;
98434   {
98435     try {
98436       (arg1)->ClearCookies();
98437     } catch (std::out_of_range& e) {
98438       {
98439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98440       };
98441     } catch (std::exception& e) {
98442       {
98443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98444       };
98445     } catch (Dali::DaliException e) {
98446       {
98447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98448       };
98449     } catch (...) {
98450       {
98451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98452       };
98453     }
98454   }
98455 }
98456
98457 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
98458     return (Dali::Toolkit::Control *)jarg1;
98459 }
98460
98461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
98462   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98463   SignalConverter::WebViewPageLoadSignal* result = NULL;
98464   {
98465     try {
98466       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
98467     } catch (std::out_of_range& e) {
98468       {
98469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98470       };
98471     } catch (std::exception& e) {
98472       {
98473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98474       };
98475     } catch (Dali::DaliException e) {
98476       {
98477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98478       };
98479     } catch (...) {
98480       {
98481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98482       };
98483     }
98484   }
98485   return (void*) result;
98486 }
98487
98488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
98489   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98490   SignalConverter::WebViewPageLoadSignal* result = NULL;
98491   {
98492     try {
98493       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
98494     } catch (std::out_of_range& e) {
98495       {
98496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98497       };
98498     } catch (std::exception& e) {
98499       {
98500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98501       };
98502     } catch (Dali::DaliException e) {
98503       {
98504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98505       };
98506     } catch (...) {
98507       {
98508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98509       };
98510     }
98511   }
98512   return (void*) result;
98513 }
98514
98515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
98516 {
98517   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98518   {
98519     try {
98520       delete object;
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 void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
98542 {
98543   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98544   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
98545   {
98546     try {
98547       proxy->Connect(callback);
98548     } catch (std::out_of_range& e) {
98549       {
98550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98551       };
98552     } catch (std::exception& e) {
98553       {
98554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98555       };
98556     } catch (Dali::DaliException e) {
98557       {
98558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98559       };
98560     } catch (...) {
98561       {
98562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98563       };
98564     }
98565   }
98566 }
98567
98568
98569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
98570   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98571   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
98572   {
98573     try {
98574       proxy->Disconnect(callback);
98575     } catch (std::out_of_range& e) {
98576       {
98577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98578       };
98579     } catch (std::exception& e) {
98580       {
98581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98582       };
98583     } catch (Dali::DaliException e) {
98584       {
98585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98586       };
98587     } catch (...) {
98588       {
98589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98590       };
98591     }
98592   }
98593 }
98594
98595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
98596   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98597   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
98598   {
98599     try {
98600       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
98601     } catch (std::out_of_range& e) {
98602       {
98603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98604       };
98605     } catch (std::exception& e) {
98606       {
98607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98608       };
98609     } catch (Dali::DaliException e) {
98610       {
98611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98612       };
98613     } catch (...) {
98614       {
98615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98616       };
98617     }
98618   }
98619   return (void*) result;
98620 }
98621
98622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
98623 {
98624   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98625   {
98626     try {
98627       delete object;
98628     } catch (std::out_of_range& e) {
98629       {
98630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98631       };
98632     } catch (std::exception& e) {
98633       {
98634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98635       };
98636     } catch (Dali::DaliException e) {
98637       {
98638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98639       };
98640     } catch (...) {
98641       {
98642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98643       };
98644     }
98645   }
98646 }
98647
98648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
98649 {
98650   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98651   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
98652   {
98653     try {
98654       proxy->Connect(callback);
98655     } catch (std::out_of_range& e) {
98656       {
98657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98658       };
98659     } catch (std::exception& e) {
98660       {
98661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98662       };
98663     } catch (Dali::DaliException e) {
98664       {
98665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98666       };
98667     } catch (...) {
98668       {
98669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98670       };
98671     }
98672   }
98673 }
98674
98675
98676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
98677   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98678   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
98679   {
98680     try {
98681       proxy->Disconnect(callback);
98682     } catch (std::out_of_range& e) {
98683       {
98684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98685       };
98686     } catch (std::exception& e) {
98687       {
98688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98689       };
98690     } catch (Dali::DaliException e) {
98691       {
98692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98693       };
98694     } catch (...) {
98695       {
98696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98697       };
98698     }
98699   }
98700 }
98701
98702 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
98703   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
98704   char * jresult = SWIG_csharp_string_callback((const char *)result);
98705   return jresult;
98706 }
98707
98708 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
98709   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
98710   return result;
98711 }
98712
98713
98714 struct NativeImageSourcePtrHandle
98715 {
98716   NativeImageSourcePtr Ptr;
98717 };
98718
98719 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
98720 {
98721   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
98722   return (NativeImageInterface*)(arg1);
98723 }
98724
98725 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
98726 {
98727   void* jresult;
98728   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
98729   {
98730     try {
98731       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
98732     }
98733     catch (std::out_of_range & e) {
98734       {
98735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98736       };
98737     }
98738     catch (std::exception & e) {
98739       {
98740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98741       };
98742     }
98743     catch (Dali::DaliException e) {
98744       {
98745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98746       };
98747     }
98748     catch (...) {
98749       {
98750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98751       };
98752     }
98753   }
98754   jresult = (void *)handle;
98755   return jresult;
98756 }
98757
98758 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
98759 {
98760   void* jresult;
98761   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
98762   jresult = (void*)( handle->Ptr.Get() );
98763   return jresult;
98764 }
98765
98766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
98767   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
98768   {
98769     try {
98770       delete arg1;
98771     }
98772     catch (std::out_of_range & e) {
98773       {
98774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
98775       };
98776     }
98777     catch (std::exception & e) {
98778       {
98779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
98780       };
98781     }
98782     catch (Dali::DaliException e) {
98783       {
98784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
98785       };
98786     }
98787     catch (...) {
98788       {
98789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
98790       };
98791     }
98792   }
98793 }
98794
98795 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
98796 {
98797   void* jresult;
98798   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
98799   uint16_t* arg2 = (uint16_t*)(jarg2);
98800   uint16_t* arg3 = (uint16_t*)(jarg3);
98801   uint16_t* arg4 = (uint16_t*)(jarg4);
98802   {
98803     try {
98804       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
98805     }
98806     catch (std::out_of_range & e) {
98807       {
98808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98809       };
98810     }
98811     catch (std::exception & e) {
98812       {
98813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98814       };
98815     }
98816     catch (Dali::DaliException e) {
98817       {
98818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98819       };
98820     }
98821     catch (...) {
98822       {
98823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98824       };
98825     }
98826   }
98827   return jresult;
98828 }
98829
98830 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
98831 {
98832   bool jresult;
98833   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
98834
98835   {
98836     try {
98837       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
98838     }
98839     catch (std::out_of_range & e) {
98840       {
98841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98842       };
98843     }
98844     catch (std::exception & e) {
98845       {
98846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98847       };
98848     }
98849     catch (Dali::DaliException e) {
98850       {
98851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98852       };
98853     }
98854     catch (...) {
98855       {
98856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98857       };
98858     }
98859   }
98860   return jresult;
98861 }
98862
98863
98864 #ifdef __cplusplus
98865 }
98866 #endif